﻿/**
 * bluebird build version 2.1.3
 * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, progress, cancel, using, filter, any, each, timers
*/
/**
 * @preserve Copyright (c) 2014 Petka Antonov
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:</p>
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 * 
 */
!function (e) { "object" == typeof exports ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : "undefined" != typeof window ? window.Promise = e() : "undefined" != typeof global ? global.Promise = e() : "undefined" != typeof self && (self.Promise = e()) }(function () {
    var define, module, exports; return (function e(t, n, r) { function s(o, u) { if (!n[o]) { if (!t[o]) { var a = typeof require == "function" && require; if (!u && a) return a(o, !0); if (i) return i(o, !0); throw new Error("Cannot find module '" + o + "'") } var f = n[o] = { exports: {} }; t[o][0].call(f.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e) }, f, f.exports, e, t, n, r) } return n[o].exports } var i = typeof require == "function" && require; for (var o = 0; o < r.length; o++) s(r[o]); return s })({
        1: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise) {
                var SomePromiseArray = Promise._SomePromiseArray;
                function Promise$_Any(promises) {
                    var ret = new SomePromiseArray(promises);
                    var promise = ret.promise();
                    if (promise.isRejected()) {
                        return promise;
                    }
                    ret.setHowMany(1);
                    ret.setUnwrap();
                    ret.init();
                    return promise;
                }


                Promise.any = function Promise$Any(promises) {
                    return Promise$_Any(promises);
                };


                Promise.prototype.any = function Promise$any() {
                    return Promise$_Any(this);
                };


            };


        }, {}], 2: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var schedule = require("./schedule.js");
            var Queue = require("./queue.js");
            var errorObj = require("./util.js").errorObj;
            var tryCatch1 = require("./util.js").tryCatch1;
            var _process = typeof process !== "undefined" ? process : void 0;


            function Async() {
                this._isTickUsed = false;
                this._schedule = schedule;
                this._length = 0;
                this._lateBuffer = new Queue(16);
                this._functionBuffer = new Queue(65536);
                var self = this;
                this.consumeFunctionBuffer = function Async$consumeFunctionBuffer() {
                    self._consumeFunctionBuffer();
                };
            }


            Async.prototype.haveItemsQueued = function Async$haveItemsQueued() {
                return this._length > 0;
            };


            Async.prototype.invokeLater = function Async$invokeLater(fn, receiver, arg) {
                if (_process !== void 0 &&
                    _process.domain != null &&
                    !fn.domain) {
                    fn = _process.domain.bind(fn);
                }
                this._lateBuffer.push(fn, receiver, arg);
                this._queueTick();
            };


            Async.prototype.invoke = function Async$invoke(fn, receiver, arg) {
                if (_process !== void 0 &&
                    _process.domain != null &&
                    !fn.domain) {
                    fn = _process.domain.bind(fn);
                }
                var functionBuffer = this._functionBuffer;
                functionBuffer.push(fn, receiver, arg);
                this._length = functionBuffer.length();
                this._queueTick();
            };


            Async.prototype._consumeFunctionBuffer =
            function Async$_consumeFunctionBuffer() {
                var functionBuffer = this._functionBuffer;
                while (functionBuffer.length() > 0) {
                    var fn = functionBuffer.shift();
                    var receiver = functionBuffer.shift();
                    var arg = functionBuffer.shift();
                    fn.call(receiver, arg);
                }
                this._reset();
                this._consumeLateBuffer();
            };


            Async.prototype._consumeLateBuffer = function Async$_consumeLateBuffer() {
                var buffer = this._lateBuffer;
                while (buffer.length() > 0) {
                    var fn = buffer.shift();
                    var receiver = buffer.shift();
                    var arg = buffer.shift();
                    var res = tryCatch1(fn, receiver, arg);
                    if (res === errorObj) {
                        this._queueTick();
                        if (fn.domain != null) {
                            fn.domain.emit("error", res.e);
                        } else {
                            throw res.e;
                        }
                    }
                }
            };


            Async.prototype._queueTick = function Async$_queue() {
                if (!this._isTickUsed) {
                    this._schedule(this.consumeFunctionBuffer);
                    this._isTickUsed = true;
                }
            };


            Async.prototype._reset = function Async$_reset() {
                this._isTickUsed = false;
                this._length = 0;
            };


            module.exports = new Async();


        }, { "./queue.js": 25, "./schedule.js": 28, "./util.js": 35 }], 3: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var Promise = require("./promise.js")();
            module.exports = Promise;
        }, { "./promise.js": 20 }], 4: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var cr = Object.create;
            var callerCache = cr && cr(null);
            var getterCache = cr && cr(null);
            callerCache[" size"] = getterCache[" size"] = 0;
            module.exports = function (Promise) {
                var util = require("./util.js");
                var canEvaluate = util.canEvaluate;
                var isIdentifier = util.isIdentifier;


                function makeMethodCaller(methodName) {
                    return new Function("obj", "                                             \n\
        'use strict'                                                         \n\
        var len = this.length;                                               \n\
        switch(len) {                                                        \n\
            case 1: return obj.methodName(this[0]);                          \n\
            case 2: return obj.methodName(this[0], this[1]);                 \n\
            case 3: return obj.methodName(this[0], this[1], this[2]);        \n\
            case 0: return obj.methodName();                                 \n\
            default: return obj.methodName.apply(obj, this);                 \n\
        }                                                                    \n\
        ".replace(/methodName/g, methodName));
                }


                function makeGetter(propertyName) {
                    return new Function("obj", "                                             \n\
        'use strict';                                                        \n\
        return obj.propertyName;                                             \n\
        ".replace("propertyName", propertyName));
                }


                function getCompiled(name, compiler, cache) {
                    var ret = cache[name];
                    if (typeof ret !== "function") {
                        if (!isIdentifier(name)) {
                            return null;
                        }
                        ret = compiler(name);
                        cache[name] = ret;
                        cache[" size"]++;
                        if (cache[" size"] > 512) {
                            var keys = Object.keys(cache);
                            for (var i = 0; i < 256; ++i) delete cache[keys[i]];
                            cache[" size"] = keys.length - 256;
                        }
                    }
                    return ret;
                }


                function getMethodCaller(name) {
                    return getCompiled(name, makeMethodCaller, callerCache);
                }


                function getGetter(name) {
                    return getCompiled(name, makeGetter, getterCache);
                }


                function caller(obj) {
                    return obj[this.pop()].apply(obj, this);
                }
                Promise.prototype.call = function Promise$call(methodName) {
                    var $_len = arguments.length; var args = new Array($_len - 1); for (var $_i = 1; $_i < $_len; ++$_i) { args[$_i - 1] = arguments[$_i]; }
                    if (canEvaluate) {
                        var maybeCaller = getMethodCaller(methodName);
                        if (maybeCaller !== null) {
                            return this._then(maybeCaller, void 0, void 0, args, void 0);
                        }
                    }
                    args.push(methodName);
                    return this._then(caller, void 0, void 0, args, void 0);
                };


                function namedGetter(obj) {
                    return obj[this];
                }
                function indexedGetter(obj) {
                    return obj[this];
                }
                Promise.prototype.get = function Promise$get(propertyName) {
                    var isIndex = (typeof propertyName === "number");
                    var getter;
                    if (!isIndex) {
                        if (canEvaluate) {
                            var maybeGetter = getGetter(propertyName);
                            getter = maybeGetter !== null ? maybeGetter : namedGetter;
                        } else {
                            getter = namedGetter;
                        }
                    } else {
                        getter = indexedGetter;
                    }
                    return this._then(getter, void 0, void 0, propertyName, void 0);
                };
            };


        }, { "./util.js": 35 }], 5: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL) {
                var errors = require("./errors.js");
                var canAttach = errors.canAttach;
                var async = require("./async.js");
                var CancellationError = errors.CancellationError;


                Promise.prototype._cancel = function Promise$_cancel(reason) {
                    if (!this.isCancellable()) return this;
                    var parent;
                    var promiseToReject = this;
                    while ((parent = promiseToReject._cancellationParent) !== void 0 &&
                        parent.isCancellable()) {
                        promiseToReject = parent;
                    }
                    promiseToReject._attachExtraTrace(reason);
                    promiseToReject._rejectUnchecked(reason);
                };


                Promise.prototype.cancel = function Promise$cancel(reason) {
                    if (!this.isCancellable()) return this;
                    reason = reason !== void 0
                        ? (canAttach(reason) ? reason : new Error(reason + ""))
                        : new CancellationError();
                    async.invokeLater(this._cancel, this, reason);
                    return this;
                };


                Promise.prototype.cancellable = function Promise$cancellable() {
                    if (this._cancellable()) return this;
                    this._setCancellable();
                    this._cancellationParent = void 0;
                    return this;
                };


                Promise.prototype.uncancellable = function Promise$uncancellable() {
                    var ret = new Promise(INTERNAL);
                    ret._propagateFrom(this, 2 | 4);
                    ret._follow(this);
                    ret._unsetCancellable();
                    return ret;
                };


                Promise.prototype.fork =
                function Promise$fork(didFulfill, didReject, didProgress) {
                    var ret = this._then(didFulfill, didReject, didProgress,
                                         void 0, void 0);


                    ret._setCancellable();
                    ret._cancellationParent = void 0;
                    return ret;
                };
            };


        }, { "./async.js": 2, "./errors.js": 10 }], 6: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function () {
                var inherits = require("./util.js").inherits;
                var defineProperty = require("./es5.js").defineProperty;


                var rignore = new RegExp(
                    "\\b(?:[a-zA-Z0-9.]+\\$_\\w+|" +
                    "tryCatch(?:1|2|3|4|Apply)|new \\w*PromiseArray|" +
                    "\\w*PromiseArray\\.\\w*PromiseArray|" +
                    "setTimeout|CatchFilter\\$_\\w+|makeNodePromisified|processImmediate|" +
                    "process._tickCallback|nextTick|Async\\$\\w+)\\b"
                );


                var rtraceline = null;
                var formatStack = null;


                function formatNonError(obj) {
                    var str;
                    if (typeof obj === "function") {
                        str = "[function " +
                            (obj.name || "anonymous") +
                            "]";
                    } else {
                        str = obj.toString();
                        var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
                        if (ruselessToString.test(str)) {
                            try {
                                var newStr = JSON.stringify(obj);
                                str = newStr;
                            }
                            catch (e) {


                            }
                        }
                        if (str.length === 0) {
                            str = "(empty array)";
                        }
                    }
                    return ("(<" + snip(str) + ">, no stack trace)");
                }


                function snip(str) {
                    var maxChars = 41;
                    if (str.length < maxChars) {
                        return str;
                    }
                    return str.substr(0, maxChars - 3) + "...";
                }


                function CapturedTrace(ignoreUntil, isTopLevel) {
                    this.captureStackTrace(CapturedTrace, isTopLevel);


                }
                inherits(CapturedTrace, Error);


                CapturedTrace.prototype.captureStackTrace =
                function CapturedTrace$captureStackTrace(ignoreUntil, isTopLevel) {
                    captureStackTrace(this, ignoreUntil, isTopLevel);
                };


                CapturedTrace.possiblyUnhandledRejection =
                function CapturedTrace$PossiblyUnhandledRejection(reason) {
                    if (typeof console === "object") {
                        var message;
                        if (typeof reason === "object" || typeof reason === "function") {
                            var stack = reason.stack;
                            message = "Possibly unhandled " + formatStack(stack, reason);
                        } else {
                            message = "Possibly unhandled " + String(reason);
                        }
                        if (typeof console.error === "function" ||
                            typeof console.error === "object") {
                            console.error(message);
                        } else if (typeof console.log === "function" ||
                            typeof console.log === "object") {
                            console.log(message);
                        }
                    }
                };


                CapturedTrace.combine = function CapturedTrace$Combine(current, prev) {
                    var curLast = current.length - 1;
                    for (var i = prev.length - 1; i >= 0; --i) {
                        var line = prev[i];
                        if (current[curLast] === line) {
                            current.pop();
                            curLast--;
                        } else {
                            break;
                        }
                    }


                    current.push("From previous event:");
                    var lines = current.concat(prev);


                    var ret = [];


                    for (var i = 0, len = lines.length; i < len; ++i) {


                        if ((rignore.test(lines[i]) ||
                            (i > 0 && !rtraceline.test(lines[i])) &&
                            lines[i] !== "From previous event:")
                       ) {
                            continue;
                        }
                        ret.push(lines[i]);
                    }
                    return ret;
                };


                CapturedTrace.isSupported = function CapturedTrace$IsSupported() {
                    return typeof captureStackTrace === "function";
                };


                var captureStackTrace = (function stackDetection() {
                    if (typeof Error.stackTraceLimit === "number" &&
                        typeof Error.captureStackTrace === "function") {
                        rtraceline = /^\s*at\s*/;
                        formatStack = function (stack, error) {
                            if (typeof stack === "string") return stack;


                            if (error.name !== void 0 &&
                                error.message !== void 0) {
                                return error.name + ". " + error.message;
                            }
                            return formatNonError(error);




                        };
                        var captureStackTrace = Error.captureStackTrace;
                        return function CapturedTrace$_captureStackTrace(
                            receiver, ignoreUntil) {
                            captureStackTrace(receiver, ignoreUntil);
                        };
                    }
                    var err = new Error();


                    if (typeof err.stack === "string" &&
                        typeof "".startsWith === "function" &&
                        (err.stack.startsWith("stackDetection@")) &&
                        stackDetection.name === "stackDetection") {


                        defineProperty(Error, "stackTraceLimit", {
                            writable: true,
                            enumerable: false,
                            configurable: false,
                            value: 25
                        });
                        rtraceline = /@/;
                        var rline = /[@\n]/;


                        formatStack = function (stack, error) {
                            if (typeof stack === "string") {
                                return (error.name + ". " + error.message + "\n" + stack);
                            }


                            if (error.name !== void 0 &&
                                error.message !== void 0) {
                                return error.name + ". " + error.message;
                            }
                            return formatNonError(error);
                        };


                        return function captureStackTrace(o) {
                            var stack = new Error().stack;
                            var split = stack.split(rline);
                            var len = split.length;
                            var ret = "";
                            for (var i = 0; i < len; i += 2) {
                                ret += split[i];
                                ret += "@";
                                ret += split[i + 1];
                                ret += "\n";
                            }
                            o.stack = ret;
                        };
                    } else {
                        formatStack = function (stack, error) {
                            if (typeof stack === "string") return stack;


                            if ((typeof error === "object" ||
                                typeof error === "function") &&
                                error.name !== void 0 &&
                                error.message !== void 0) {
                                return error.name + ". " + error.message;
                            }
                            return formatNonError(error);
                        };


                        return null;
                    }
                })();


                return CapturedTrace;
            };


        }, { "./es5.js": 12, "./util.js": 35 }], 7: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (NEXT_FILTER) {
                var util = require("./util.js");
                var errors = require("./errors.js");
                var tryCatch1 = util.tryCatch1;
                var errorObj = util.errorObj;
                var keys = require("./es5.js").keys;
                var TypeError = errors.TypeError;


                function CatchFilter(instances, callback, promise) {
                    this._instances = instances;
                    this._callback = callback;
                    this._promise = promise;
                }


                function CatchFilter$_safePredicate(predicate, e) {
                    var safeObject = {};
                    var retfilter = tryCatch1(predicate, safeObject, e);


                    if (retfilter === errorObj) return retfilter;


                    var safeKeys = keys(safeObject);
                    if (safeKeys.length) {
                        errorObj.e = new TypeError(
                            "Catch filter must inherit from Error "
                          + "or be a simple predicate function");
                        return errorObj;
                    }
                    return retfilter;
                }


                CatchFilter.prototype.doFilter = function CatchFilter$_doFilter(e) {
                    var cb = this._callback;
                    var promise = this._promise;
                    var boundTo = promise._boundTo;
                    for (var i = 0, len = this._instances.length; i < len; ++i) {
                        var item = this._instances[i];
                        var itemIsErrorType = item === Error ||
                            (item != null && item.prototype instanceof Error);


                        if (itemIsErrorType && e instanceof item) {
                            var ret = tryCatch1(cb, boundTo, e);
                            if (ret === errorObj) {
                                NEXT_FILTER.e = ret.e;
                                return NEXT_FILTER;
                            }
                            return ret;
                        } else if (typeof item === "function" && !itemIsErrorType) {
                            var shouldHandle = CatchFilter$_safePredicate(item, e);
                            if (shouldHandle === errorObj) {
                                var trace = errors.canAttach(errorObj.e)
                                    ? errorObj.e
                                    : new Error(errorObj.e + "");
                                this._promise._attachExtraTrace(trace);
                                e = errorObj.e;
                                break;
                            } else if (shouldHandle) {
                                var ret = tryCatch1(cb, boundTo, e);
                                if (ret === errorObj) {
                                    NEXT_FILTER.e = ret.e;
                                    return NEXT_FILTER;
                                }
                                return ret;
                            }
                        }
                    }
                    NEXT_FILTER.e = e;
                    return NEXT_FILTER;
                };


                return CatchFilter;
            };


        }, { "./errors.js": 10, "./es5.js": 12, "./util.js": 35 }], 8: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var util = require("./util.js");
            var isPrimitive = util.isPrimitive;
            var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;


            module.exports = function (Promise) {
                var returner = function Promise$_returner() {
                    return this;
                };
                var thrower = function Promise$_thrower() {
                    throw this;
                };


                var wrapper = function Promise$_wrapper(value, action) {
                    if (action === 1) {
                        return function Promise$_thrower() {
                            throw value;
                        };
                    } else if (action === 2) {
                        return function Promise$_returner() {
                            return value;
                        };
                    }
                };




                Promise.prototype["return"] =
                Promise.prototype.thenReturn =
                function Promise$thenReturn(value) {
                    if (wrapsPrimitiveReceiver && isPrimitive(value)) {
                        return this._then(
                            wrapper(value, 2),
                            void 0,
                            void 0,
                            void 0,
                            void 0
                       );
                    }
                    return this._then(returner, void 0, void 0, value, void 0);
                };


                Promise.prototype["throw"] =
                Promise.prototype.thenThrow =
                function Promise$thenThrow(reason) {
                    if (wrapsPrimitiveReceiver && isPrimitive(reason)) {
                        return this._then(
                            wrapper(reason, 1),
                            void 0,
                            void 0,
                            void 0,
                            void 0
                       );
                    }
                    return this._then(thrower, void 0, void 0, reason, void 0);
                };
            };


        }, { "./util.js": 35 }], 9: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL) {
                var PromiseReduce = Promise.reduce;


                Promise.prototype.each = function Promise$each(fn) {
                    return PromiseReduce(this, fn, null, INTERNAL);
                };


                Promise.each = function Promise$Each(promises, fn) {
                    return PromiseReduce(promises, fn, null, INTERNAL);
                };
            };


        }, {}], 10: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var Objectfreeze = require("./es5.js").freeze;
            var util = require("./util.js");
            var inherits = util.inherits;
            var notEnumerableProp = util.notEnumerableProp;


            function markAsOriginatingFromRejection(e) {
                try {
                    notEnumerableProp(e, "isOperational", true);
                }
                catch (ignore) { }
            }


            function originatesFromRejection(e) {
                if (e == null) return false;
                return ((e instanceof OperationalError) ||
                    e["isOperational"] === true);
            }


            function isError(obj) {
                return obj instanceof Error;
            }


            function canAttach(obj) {
                return isError(obj);
            }


            function subError(nameProperty, defaultMessage) {
                function SubError(message) {
                    if (!(this instanceof SubError)) return new SubError(message);
                    this.message = typeof message === "string" ? message : defaultMessage;
                    this.name = nameProperty;
                    if (Error.captureStackTrace) {
                        Error.captureStackTrace(this, this.constructor);
                    }
                }
                inherits(SubError, Error);
                return SubError;
            }


            var _TypeError, _RangeError;
            var CancellationError = subError("CancellationError", "cancellation error");
            var TimeoutError = subError("TimeoutError", "timeout error");
            var AggregateError = subError("AggregateError", "aggregate error");
            try {
                _TypeError = TypeError;
                _RangeError = RangeError;
            } catch (e) {
                _TypeError = subError("TypeError", "type error");
                _RangeError = subError("RangeError", "range error");
            }


            var methods = ("join pop push shift unshift slice filter forEach some " +
                "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");


            for (var i = 0; i < methods.length; ++i) {
                if (typeof Array.prototype[methods[i]] === "function") {
                    AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
                }
            }


            AggregateError.prototype.length = 0;
            AggregateError.prototype["isOperational"] = true;
            var level = 0;
            AggregateError.prototype.toString = function () {
                var indent = Array(level * 4 + 1).join(" ");
                var ret = "\n" + indent + "AggregateError of:" + "\n";
                level++;
                indent = Array(level * 4 + 1).join(" ");
                for (var i = 0; i < this.length; ++i) {
                    var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
                    var lines = str.split("\n");
                    for (var j = 0; j < lines.length; ++j) {
                        lines[j] = indent + lines[j];
                    }
                    str = lines.join("\n");
                    ret += str + "\n";
                }
                level--;
                return ret;
            };


            function OperationalError(message) {
                this.name = "OperationalError";
                this.message = message;
                this.cause = message;
                this["isOperational"] = true;


                if (message instanceof Error) {
                    this.message = message.message;
                    this.stack = message.stack;
                } else if (Error.captureStackTrace) {
                    Error.captureStackTrace(this, this.constructor);
                }


            }
            inherits(OperationalError, Error);


            var key = "__BluebirdErrorTypes__";
            var errorTypes = Error[key];
            if (!errorTypes) {
                errorTypes = Objectfreeze({
                    CancellationError: CancellationError,
                    TimeoutError: TimeoutError,
                    OperationalError: OperationalError,
                    RejectionError: OperationalError,
                    AggregateError: AggregateError
                });
                notEnumerableProp(Error, key, errorTypes);
            }


            module.exports = {
                Error: Error,
                TypeError: _TypeError,
                RangeError: _RangeError,
                CancellationError: errorTypes.CancellationError,
                OperationalError: errorTypes.OperationalError,
                TimeoutError: errorTypes.TimeoutError,
                AggregateError: errorTypes.AggregateError,
                originatesFromRejection: originatesFromRejection,
                markAsOriginatingFromRejection: markAsOriginatingFromRejection,
                canAttach: canAttach
            };


        }, { "./es5.js": 12, "./util.js": 35 }], 11: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise) {
                var TypeError = require('./errors.js').TypeError;


                function apiRejection(msg) {
                    var error = new TypeError(msg);
                    var ret = Promise.rejected(error);
                    var parent = ret._peekContext();
                    if (parent != null) {
                        parent._attachExtraTrace(error);
                    }
                    return ret;
                }


                return apiRejection;
            };


        }, { "./errors.js": 10 }], 12: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            var isES5 = (function () {
                "use strict";
                return this === void 0;
            })();


            if (isES5) {
                module.exports = {
                    freeze: Object.freeze,
                    defineProperty: Object.defineProperty,
                    keys: Object.keys,
                    getPrototypeOf: Object.getPrototypeOf,
                    isArray: Array.isArray,
                    isES5: isES5
                };
            } else {
                var has = {}.hasOwnProperty;
                var str = {}.toString;
                var proto = {}.constructor.prototype;


                var ObjectKeys = function ObjectKeys(o) {
                    var ret = [];
                    for (var key in o) {
                        if (has.call(o, key)) {
                            ret.push(key);
                        }
                    }
                    return ret;
                }


                var ObjectDefineProperty = function ObjectDefineProperty(o, key, desc) {
                    o[key] = desc.value;
                    return o;
                }


                var ObjectFreeze = function ObjectFreeze(obj) {
                    return obj;
                }


                var ObjectGetPrototypeOf = function ObjectGetPrototypeOf(obj) {
                    try {
                        return Object(obj).constructor.prototype;
                    }
                    catch (e) {
                        return proto;
                    }
                }


                var ArrayIsArray = function ArrayIsArray(obj) {
                    try {
                        return str.call(obj) === "[object Array]";
                    }
                    catch (e) {
                        return false;
                    }
                }


                module.exports = {
                    isArray: ArrayIsArray,
                    keys: ObjectKeys,
                    defineProperty: ObjectDefineProperty,
                    freeze: ObjectFreeze,
                    getPrototypeOf: ObjectGetPrototypeOf,
                    isES5: isES5
                };
            }


        }, {}], 13: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL) {
                var PromiseMap = Promise.map;


                Promise.prototype.filter = function Promise$filter(fn, options) {
                    return PromiseMap(this, fn, options, INTERNAL);
                };


                Promise.filter = function Promise$Filter(promises, fn, options) {
                    return PromiseMap(promises, fn, options, INTERNAL);
                };
            };


        }, {}], 14: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, NEXT_FILTER, cast) {
                var util = require("./util.js");
                var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
                var isPrimitive = util.isPrimitive;
                var thrower = util.thrower;


                function returnThis() {
                    return this;
                }
                function throwThis() {
                    throw this;
                }
                function return$(r) {
                    return function Promise$_returner() {
                        return r;
                    };
                }
                function throw$(r) {
                    return function Promise$_thrower() {
                        throw r;
                    };
                }
                function promisedFinally(ret, reasonOrValue, isFulfilled) {
                    var then;
                    if (wrapsPrimitiveReceiver && isPrimitive(reasonOrValue)) {
                        then = isFulfilled ? return$(reasonOrValue) : throw$(reasonOrValue);
                    } else {
                        then = isFulfilled ? returnThis : throwThis;
                    }
                    return ret._then(then, thrower, void 0, reasonOrValue, void 0);
                }


                function finallyHandler(reasonOrValue) {
                    var promise = this.promise;
                    var handler = this.handler;


                    var ret = promise._isBound()
                                    ? handler.call(promise._boundTo)
                                    : handler();


                    if (ret !== void 0) {
                        var maybePromise = cast(ret, void 0);
                        if (maybePromise instanceof Promise) {
                            return promisedFinally(maybePromise, reasonOrValue,
                                                    promise.isFulfilled());
                        }
                    }


                    if (promise.isRejected()) {
                        NEXT_FILTER.e = reasonOrValue;
                        return NEXT_FILTER;
                    } else {
                        return reasonOrValue;
                    }
                }


                function tapHandler(value) {
                    var promise = this.promise;
                    var handler = this.handler;


                    var ret = promise._isBound()
                                    ? handler.call(promise._boundTo, value)
                                    : handler(value);


                    if (ret !== void 0) {
                        var maybePromise = cast(ret, void 0);
                        if (maybePromise instanceof Promise) {
                            return promisedFinally(maybePromise, value, true);
                        }
                    }
                    return value;
                }


                Promise.prototype._passThroughHandler =
                function Promise$_passThroughHandler(handler, isFinally) {
                    if (typeof handler !== "function") return this.then();


                    var promiseAndHandler = {
                        promise: this,
                        handler: handler
                    };


                    return this._then(
                            isFinally ? finallyHandler : tapHandler,
                            isFinally ? finallyHandler : void 0, void 0,
                            promiseAndHandler, void 0);
                };


                Promise.prototype.lastly =
                Promise.prototype["finally"] = function Promise$finally(handler) {
                    return this._passThroughHandler(handler, true);
                };


                Promise.prototype.tap = function Promise$tap(handler) {
                    return this._passThroughHandler(handler, false);
                };
            };


        }, { "./util.js": 35 }], 15: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, apiRejection, INTERNAL, cast) {
                var errors = require("./errors.js");
                var TypeError = errors.TypeError;
                var deprecated = require("./util.js").deprecated;
                var util = require("./util.js");
                var errorObj = util.errorObj;
                var tryCatch1 = util.tryCatch1;
                var yieldHandlers = [];


                function promiseFromYieldHandler(value, yieldHandlers) {
                    var _errorObj = errorObj;
                    var _Promise = Promise;
                    var len = yieldHandlers.length;
                    for (var i = 0; i < len; ++i) {
                        var result = tryCatch1(yieldHandlers[i], void 0, value);
                        if (result === _errorObj) {
                            return _Promise.reject(_errorObj.e);
                        }
                        var maybePromise = cast(result, promiseFromYieldHandler);
                        if (maybePromise instanceof _Promise) return maybePromise;
                    }
                    return null;
                }


                function PromiseSpawn(generatorFunction, receiver, yieldHandler) {
                    var promise = this._promise = new Promise(INTERNAL);
                    promise._setTrace(void 0);
                    this._generatorFunction = generatorFunction;
                    this._receiver = receiver;
                    this._generator = void 0;
                    this._yieldHandlers = typeof yieldHandler === "function"
                        ? [yieldHandler].concat(yieldHandlers)
                        : yieldHandlers;
                }


                PromiseSpawn.prototype.promise = function PromiseSpawn$promise() {
                    return this._promise;
                };


                PromiseSpawn.prototype._run = function PromiseSpawn$_run() {
                    this._generator = this._generatorFunction.call(this._receiver);
                    this._receiver =
                        this._generatorFunction = void 0;
                    this._next(void 0);
                };


                PromiseSpawn.prototype._continue = function PromiseSpawn$_continue(result) {
                    if (result === errorObj) {
                        this._generator = void 0;
                        var trace = errors.canAttach(result.e)
                            ? result.e : new Error(result.e + "");
                        this._promise._attachExtraTrace(trace);
                        this._promise._reject(result.e, trace);
                        return;
                    }


                    var value = result.value;
                    if (result.done === true) {
                        this._generator = void 0;
                        if (!this._promise._tryFollow(value)) {
                            this._promise._fulfill(value);
                        }
                    } else {
                        var maybePromise = cast(value, void 0);
                        if (!(maybePromise instanceof Promise)) {
                            maybePromise =
                                promiseFromYieldHandler(maybePromise, this._yieldHandlers);
                            if (maybePromise === null) {
                                this._throw(new TypeError("A value was yielded that could not be treated as a promise"));
                                return;
                            }
                        }
                        maybePromise._then(
                            this._next,
                            this._throw,
                            void 0,
                            this,
                            null
                       );
                    }
                };


                PromiseSpawn.prototype._throw = function PromiseSpawn$_throw(reason) {
                    if (errors.canAttach(reason))
                        this._promise._attachExtraTrace(reason);
                    this._continue(
                        tryCatch1(this._generator["throw"], this._generator, reason)
                   );
                };


                PromiseSpawn.prototype._next = function PromiseSpawn$_next(value) {
                    this._continue(
                        tryCatch1(this._generator.next, this._generator, value)
                   );
                };


                Promise.coroutine =
                function Promise$Coroutine(generatorFunction, options) {
                    if (typeof generatorFunction !== "function") {
                        throw new TypeError("generatorFunction must be a function");
                    }
                    var yieldHandler = Object(options).yieldHandler;
                    var PromiseSpawn$ = PromiseSpawn;
                    return function () {
                        var generator = generatorFunction.apply(this, arguments);
                        var spawn = new PromiseSpawn$(void 0, void 0, yieldHandler);
                        spawn._generator = generator;
                        spawn._next(void 0);
                        return spawn.promise();
                    };
                };


                Promise.coroutine.addYieldHandler = function (fn) {
                    if (typeof fn !== "function") throw new TypeError("fn must be a function");
                    yieldHandlers.push(fn);
                };


                Promise.spawn = function Promise$Spawn(generatorFunction) {
                    deprecated("Promise.spawn is deprecated. Use Promise.coroutine instead.");
                    if (typeof generatorFunction !== "function") {
                        return apiRejection("generatorFunction must be a function");
                    }
                    var spawn = new PromiseSpawn(generatorFunction, this);
                    var ret = spawn.promise();
                    spawn._run(Promise.spawn);
                    return ret;
                };
            };


        }, { "./errors.js": 10, "./util.js": 35 }], 16: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports =
            function (Promise, PromiseArray, cast, INTERNAL) {
                var util = require("./util.js");
                var canEvaluate = util.canEvaluate;
                var tryCatch1 = util.tryCatch1;
                var errorObj = util.errorObj;




                if (canEvaluate) {
                    var thenCallback = function (i) {
                        return new Function("value", "holder", "                             \n\
            'use strict';                                                    \n\
            holder.pIndex = value;                                           \n\
            holder.checkFulfillment(this);                                   \n\
            ".replace(/Index/g, i));
                    };


                    var caller = function (count) {
                        var values = [];
                        for (var i = 1; i <= count; ++i) values.push("holder.p" + i);
                        return new Function("holder", "                                      \n\
            'use strict';                                                    \n\
            var callback = holder.fn;                                        \n\
            return callback(values);                                         \n\
            ".replace(/values/g, values.join(", ")));
                    };
                    var thenCallbacks = [];
                    var callers = [void 0];
                    for (var i = 1; i <= 5; ++i) {
                        thenCallbacks.push(thenCallback(i));
                        callers.push(caller(i));
                    }


                    var Holder = function (total, fn) {
                        this.p1 = this.p2 = this.p3 = this.p4 = this.p5 = null;
                        this.fn = fn;
                        this.total = total;
                        this.now = 0;
                    };


                    Holder.prototype.callers = callers;
                    Holder.prototype.checkFulfillment = function (promise) {
                        var now = this.now;
                        now++;
                        var total = this.total;
                        if (now >= total) {
                            var handler = this.callers[total];
                            var ret = tryCatch1(handler, void 0, this);
                            if (ret === errorObj) {
                                promise._rejectUnchecked(ret.e);
                            } else if (!promise._tryFollow(ret)) {
                                promise._fulfillUnchecked(ret);
                            }
                        } else {
                            this.now = now;
                        }
                    };
                }








                Promise.join = function Promise$Join() {
                    var last = arguments.length - 1;
                    var fn;
                    if (last > 0 && typeof arguments[last] === "function") {
                        fn = arguments[last];
                        if (last < 6 && canEvaluate) {
                            var ret = new Promise(INTERNAL);
                            ret._setTrace(void 0);
                            var holder = new Holder(last, fn);
                            var reject = ret._reject;
                            var callbacks = thenCallbacks;
                            for (var i = 0; i < last; ++i) {
                                var maybePromise = cast(arguments[i], void 0);
                                if (maybePromise instanceof Promise) {
                                    if (maybePromise.isPending()) {
                                        maybePromise._then(callbacks[i], reject,
                                                           void 0, ret, holder);
                                    } else if (maybePromise.isFulfilled()) {
                                        callbacks[i].call(ret,
                                                          maybePromise._settledValue, holder);
                                    } else {
                                        ret._reject(maybePromise._settledValue);
                                        maybePromise._unsetRejectionIsUnhandled();
                                    }
                                } else {
                                    callbacks[i].call(ret, maybePromise, holder);
                                }
                            }
                            return ret;
                        }
                    }
                    var $_len = arguments.length; var args = new Array($_len); for (var $_i = 0; $_i < $_len; ++$_i) { args[$_i] = arguments[$_i]; }
                    var ret = new PromiseArray(args).promise();
                    return fn !== void 0 ? ret.spread(fn) : ret;
                };


            };


        }, { "./util.js": 35 }], 17: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, PromiseArray, apiRejection, cast, INTERNAL) {
                var util = require("./util.js");
                var tryCatch3 = util.tryCatch3;
                var errorObj = util.errorObj;
                var PENDING = {};
                var EMPTY_ARRAY = [];


                function MappingPromiseArray(promises, fn, limit, _filter) {
                    this.constructor$(promises);
                    this._callback = fn;
                    this._preservedValues = _filter === INTERNAL
                        ? new Array(this.length())
                        : null;
                    this._limit = limit;
                    this._inFlight = 0;
                    this._queue = limit >= 1 ? [] : EMPTY_ARRAY;
                    this._init$(void 0, -2);
                }
                util.inherits(MappingPromiseArray, PromiseArray);


                MappingPromiseArray.prototype._init = function MappingPromiseArray$_init() { };


                MappingPromiseArray.prototype._promiseFulfilled =
                function MappingPromiseArray$_promiseFulfilled(value, index) {
                    var values = this._values;
                    if (values === null) return;


                    var length = this.length();
                    var preservedValues = this._preservedValues;
                    var limit = this._limit;
                    if (values[index] === PENDING) {
                        values[index] = value;
                        if (limit >= 1) {
                            this._inFlight--;
                            this._drainQueue();
                            if (this._isResolved()) return;
                        }
                    } else {
                        if (limit >= 1 && this._inFlight >= limit) {
                            values[index] = value;
                            this._queue.push(index);
                            return;
                        }
                        if (preservedValues !== null) preservedValues[index] = value;


                        var callback = this._callback;
                        var receiver = this._promise._boundTo;
                        var ret = tryCatch3(callback, receiver, value, index, length);
                        if (ret === errorObj) return this._reject(ret.e);


                        var maybePromise = cast(ret, void 0);
                        if (maybePromise instanceof Promise) {
                            if (maybePromise.isPending()) {
                                if (limit >= 1) this._inFlight++;
                                values[index] = PENDING;
                                return maybePromise._proxyPromiseArray(this, index);
                            } else if (maybePromise.isFulfilled()) {
                                ret = maybePromise.value();
                            } else {
                                maybePromise._unsetRejectionIsUnhandled();
                                return this._reject(maybePromise.reason());
                            }
                        }
                        values[index] = ret;
                    }
                    var totalResolved = ++this._totalResolved;
                    if (totalResolved >= length) {
                        if (preservedValues !== null) {
                            this._filter(values, preservedValues);
                        } else {
                            this._resolve(values);
                        }


                    }
                };


                MappingPromiseArray.prototype._drainQueue =
                function MappingPromiseArray$_drainQueue() {
                    var queue = this._queue;
                    var limit = this._limit;
                    var values = this._values;
                    while (queue.length > 0 && this._inFlight < limit) {
                        var index = queue.pop();
                        this._promiseFulfilled(values[index], index);
                    }
                };


                MappingPromiseArray.prototype._filter =
                function MappingPromiseArray$_filter(booleans, values) {
                    var len = values.length;
                    var ret = new Array(len);
                    var j = 0;
                    for (var i = 0; i < len; ++i) {
                        if (booleans[i]) ret[j++] = values[i];
                    }
                    ret.length = j;
                    this._resolve(ret);
                };


                MappingPromiseArray.prototype.preservedValues =
                function MappingPromiseArray$preserveValues() {
                    return this._preservedValues;
                };


                function map(promises, fn, options, _filter) {
                    var limit = typeof options === "object" && options !== null
                        ? options.concurrency
                        : 0;
                    limit = typeof limit === "number" &&
                        isFinite(limit) && limit >= 1 ? limit : 0;
                    return new MappingPromiseArray(promises, fn, limit, _filter);
                }


                Promise.prototype.map = function Promise$map(fn, options) {
                    if (typeof fn !== "function") return apiRejection("fn must be a function");


                    return map(this, fn, options, null).promise();
                };


                Promise.map = function Promise$Map(promises, fn, options, _filter) {
                    if (typeof fn !== "function") return apiRejection("fn must be a function");
                    return map(promises, fn, options, _filter).promise();
                };




            };


        }, { "./util.js": 35 }], 18: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise) {
                var util = require("./util.js");
                var async = require("./async.js");
                var tryCatch2 = util.tryCatch2;
                var tryCatch1 = util.tryCatch1;
                var errorObj = util.errorObj;


                function thrower(r) {
                    throw r;
                }


                function Promise$_spreadAdapter(val, receiver) {
                    if (!util.isArray(val)) return Promise$_successAdapter(val, receiver);
                    var ret = util.tryCatchApply(this, [null].concat(val), receiver);
                    if (ret === errorObj) {
                        async.invokeLater(thrower, void 0, ret.e);
                    }
                }


                function Promise$_successAdapter(val, receiver) {
                    var nodeback = this;
                    var ret = val === void 0
                        ? tryCatch1(nodeback, receiver, null)
                        : tryCatch2(nodeback, receiver, null, val);
                    if (ret === errorObj) {
                        async.invokeLater(thrower, void 0, ret.e);
                    }
                }
                function Promise$_errorAdapter(reason, receiver) {
                    var nodeback = this;
                    var ret = tryCatch1(nodeback, receiver, reason);
                    if (ret === errorObj) {
                        async.invokeLater(thrower, void 0, ret.e);
                    }
                }


                Promise.prototype.nodeify = function Promise$nodeify(nodeback, options) {
                    if (typeof nodeback == "function") {
                        var adapter = Promise$_successAdapter;
                        if (options !== void 0 && Object(options).spread) {
                            adapter = Promise$_spreadAdapter;
                        }
                        this._then(
                            adapter,
                            Promise$_errorAdapter,
                            void 0,
                            nodeback,
                            this._boundTo
                        );
                    }
                    return this;
                };
            };


        }, { "./async.js": 2, "./util.js": 35 }], 19: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, PromiseArray) {
                var util = require("./util.js");
                var async = require("./async.js");
                var errors = require("./errors.js");
                var tryCatch1 = util.tryCatch1;
                var errorObj = util.errorObj;


                Promise.prototype.progressed = function Promise$progressed(handler) {
                    return this._then(void 0, void 0, handler, void 0, void 0);
                };


                Promise.prototype._progress = function Promise$_progress(progressValue) {
                    if (this._isFollowingOrFulfilledOrRejected()) return;
                    this._progressUnchecked(progressValue);


                };


                Promise.prototype._progressHandlerAt =
                function Promise$_progressHandlerAt(index) {
                    return index === 0
                        ? this._progressHandler0
                        : this[(index << 2) + index - 5 + 2];
                };


                Promise.prototype._doProgressWith =
                function Promise$_doProgressWith(progression) {
                    var progressValue = progression.value;
                    var handler = progression.handler;
                    var promise = progression.promise;
                    var receiver = progression.receiver;


                    var ret = tryCatch1(handler, receiver, progressValue);
                    if (ret === errorObj) {
                        if (ret.e != null &&
                            ret.e.name !== "StopProgressPropagation") {
                            var trace = errors.canAttach(ret.e)
                                ? ret.e : new Error(ret.e + "");
                            promise._attachExtraTrace(trace);
                            promise._progress(ret.e);
                        }
                    } else if (ret instanceof Promise) {
                        ret._then(promise._progress, null, null, promise, void 0);
                    } else {
                        promise._progress(ret);
                    }
                };




                Promise.prototype._progressUnchecked =
                function Promise$_progressUnchecked(progressValue) {
                    if (!this.isPending()) return;
                    var len = this._length();
                    var progress = this._progress;
                    for (var i = 0; i < len; i++) {
                        var handler = this._progressHandlerAt(i);
                        var promise = this._promiseAt(i);
                        if (!(promise instanceof Promise)) {
                            var receiver = this._receiverAt(i);
                            if (typeof handler === "function") {
                                handler.call(receiver, progressValue, promise);
                            } else if (receiver instanceof Promise && receiver._isProxied()) {
                                receiver._progressUnchecked(progressValue);
                            } else if (receiver instanceof PromiseArray) {
                                receiver._promiseProgressed(progressValue, promise);
                            }
                            continue;
                        }


                        if (typeof handler === "function") {
                            async.invoke(this._doProgressWith, this, {
                                handler: handler,
                                promise: promise,
                                receiver: this._receiverAt(i),
                                value: progressValue
                            });
                        } else {
                            async.invoke(progress, promise, progressValue);
                        }
                    }
                };
            };


        }, { "./async.js": 2, "./errors.js": 10, "./util.js": 35 }], 20: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var old;
            if (typeof Promise !== "undefined") old = Promise;
            function noConflict(bluebird) {
                try { if (Promise === bluebird) Promise = old; }
                catch (e) { }
                return bluebird;
            }
            module.exports = function () {
                var util = require("./util.js");
                var async = require("./async.js");
                var errors = require("./errors.js");


                var INTERNAL = function () { };
                var APPLY = {};
                var NEXT_FILTER = { e: null };


                var cast = require("./thenables.js")(Promise, INTERNAL);
                var PromiseArray = require("./promise_array.js")(Promise, INTERNAL, cast);
                var CapturedTrace = require("./captured_trace.js")();
                var CatchFilter = require("./catch_filter.js")(NEXT_FILTER);
                var PromiseResolver = require("./promise_resolver.js");


                var isArray = util.isArray;


                var errorObj = util.errorObj;
                var tryCatch1 = util.tryCatch1;
                var tryCatch2 = util.tryCatch2;
                var tryCatchApply = util.tryCatchApply;
                var RangeError = errors.RangeError;
                var TypeError = errors.TypeError;
                var CancellationError = errors.CancellationError;
                var TimeoutError = errors.TimeoutError;
                var OperationalError = errors.OperationalError;
                var originatesFromRejection = errors.originatesFromRejection;
                var markAsOriginatingFromRejection = errors.markAsOriginatingFromRejection;
                var canAttach = errors.canAttach;
                var thrower = util.thrower;
                var apiRejection = require("./errors_api_rejection")(Promise);




                var makeSelfResolutionError = function Promise$_makeSelfResolutionError() {
                    return new TypeError("circular promise resolution chain");
                };


                function Promise(resolver) {
                    if (typeof resolver !== "function") {
                        throw new TypeError("the promise constructor requires a resolver function");
                    }
                    if (this.constructor !== Promise) {
                        throw new TypeError("the promise constructor cannot be invoked directly");
                    }
                    this._bitField = 0;
                    this._fulfillmentHandler0 = void 0;
                    this._rejectionHandler0 = void 0;
                    this._promise0 = void 0;
                    this._receiver0 = void 0;
                    this._settledValue = void 0;
                    this._boundTo = void 0;
                    if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
                }


                Promise.prototype.bind = function Promise$bind(thisArg) {
                    var ret = new Promise(INTERNAL);
                    ret._follow(this);
                    ret._propagateFrom(this, 2 | 1);
                    ret._setBoundTo(thisArg);
                    return ret;
                };


                Promise.prototype.toString = function Promise$toString() {
                    return "[object Promise]";
                };


                Promise.prototype.caught = Promise.prototype["catch"] =
                function Promise$catch(fn) {
                    var len = arguments.length;
                    if (len > 1) {
                        var catchInstances = new Array(len - 1),
                            j = 0, i;
                        for (i = 0; i < len - 1; ++i) {
                            var item = arguments[i];
                            if (typeof item === "function") {
                                catchInstances[j++] = item;
                            } else {
                                var catchFilterTypeError =
                                    new TypeError(
                                        "A catch filter must be an error constructor "
                                        + "or a filter function");


                                this._attachExtraTrace(catchFilterTypeError);
                                async.invoke(this._reject, this, catchFilterTypeError);
                                return;
                            }
                        }
                        catchInstances.length = j;
                        fn = arguments[i];


                        this._resetTrace();
                        var catchFilter = new CatchFilter(catchInstances, fn, this);
                        return this._then(void 0, catchFilter.doFilter, void 0,
                            catchFilter, void 0);
                    }
                    return this._then(void 0, fn, void 0, void 0, void 0);
                };


                Promise.prototype.then =
                function Promise$then(didFulfill, didReject, didProgress) {
                    return this._then(didFulfill, didReject, didProgress,
                        void 0, void 0);
                };




                Promise.prototype.done =
                function Promise$done(didFulfill, didReject, didProgress) {
                    var promise = this._then(didFulfill, didReject, didProgress,
                        void 0, void 0);
                    promise._setIsFinal();
                };


                Promise.prototype.spread = function Promise$spread(didFulfill, didReject) {
                    return this._then(didFulfill, didReject, void 0,
                        APPLY, void 0);
                };


                Promise.prototype.isCancellable = function Promise$isCancellable() {
                    return !this.isResolved() &&
                        this._cancellable();
                };


                Promise.prototype.toJSON = function Promise$toJSON() {
                    var ret = {
                        isFulfilled: false,
                        isRejected: false,
                        fulfillmentValue: void 0,
                        rejectionReason: void 0
                    };
                    if (this.isFulfilled()) {
                        ret.fulfillmentValue = this._settledValue;
                        ret.isFulfilled = true;
                    } else if (this.isRejected()) {
                        ret.rejectionReason = this._settledValue;
                        ret.isRejected = true;
                    }
                    return ret;
                };


                Promise.prototype.all = function Promise$all() {
                    return new PromiseArray(this).promise();
                };




                Promise.is = function Promise$Is(val) {
                    return val instanceof Promise;
                };


                Promise.all = function Promise$All(promises) {
                    return new PromiseArray(promises).promise();
                };


                Promise.prototype.error = function Promise$_error(fn) {
                    return this.caught(originatesFromRejection, fn);
                };


                Promise.prototype._resolveFromSyncValue =
                function Promise$_resolveFromSyncValue(value) {
                    if (value === errorObj) {
                        this._cleanValues();
                        this._setRejected();
                        this._settledValue = value.e;
                        this._ensurePossibleRejectionHandled();
                    } else {
                        var maybePromise = cast(value, void 0);
                        if (maybePromise instanceof Promise) {
                            this._follow(maybePromise);
                        } else {
                            this._cleanValues();
                            this._setFulfilled();
                            this._settledValue = value;
                        }
                    }
                };


                Promise.method = function Promise$_Method(fn) {
                    if (typeof fn !== "function") {
                        throw new TypeError("fn must be a function");
                    }
                    return function Promise$_method() {
                        var value;
                        switch (arguments.length) {
                            case 0: value = tryCatch1(fn, this, void 0); break;
                            case 1: value = tryCatch1(fn, this, arguments[0]); break;
                            case 2: value = tryCatch2(fn, this, arguments[0], arguments[1]); break;
                            default:
                                var $_len = arguments.length; var args = new Array($_len); for (var $_i = 0; $_i < $_len; ++$_i) { args[$_i] = arguments[$_i]; }
                                value = tryCatchApply(fn, args, this); break;
                        }
                        var ret = new Promise(INTERNAL);
                        ret._setTrace(void 0);
                        ret._resolveFromSyncValue(value);
                        return ret;
                    };
                };


                Promise.attempt = Promise["try"] = function Promise$_Try(fn, args, ctx) {
                    if (typeof fn !== "function") {
                        return apiRejection("fn must be a function");
                    }
                    var value = isArray(args)
                        ? tryCatchApply(fn, args, ctx)
                        : tryCatch1(fn, ctx, args);


                    var ret = new Promise(INTERNAL);
                    ret._setTrace(void 0);
                    ret._resolveFromSyncValue(value);
                    return ret;
                };


                Promise.defer = Promise.pending = function Promise$Defer() {
                    var promise = new Promise(INTERNAL);
                    promise._setTrace(void 0);
                    return new PromiseResolver(promise);
                };


                Promise.bind = function Promise$Bind(thisArg) {
                    var ret = new Promise(INTERNAL);
                    ret._setTrace(void 0);
                    ret._setFulfilled();
                    ret._setBoundTo(thisArg);
                    return ret;
                };


                Promise.cast = function Promise$_Cast(obj) {
                    var ret = cast(obj, void 0);
                    if (!(ret instanceof Promise)) {
                        var val = ret;
                        ret = new Promise(INTERNAL);
                        ret._setTrace(void 0);
                        ret._setFulfilled();
                        ret._cleanValues();
                        ret._settledValue = val;
                    }
                    return ret;
                };


                Promise.resolve = Promise.fulfilled = Promise.cast;


                Promise.reject = Promise.rejected = function Promise$Reject(reason) {
                    var ret = new Promise(INTERNAL);
                    ret._setTrace(void 0);
                    markAsOriginatingFromRejection(reason);
                    ret._cleanValues();
                    ret._setRejected();
                    ret._settledValue = reason;
                    if (!canAttach(reason)) {
                        var trace = new Error(reason + "");
                        ret._setCarriedStackTrace(trace);
                    }
                    ret._ensurePossibleRejectionHandled();
                    return ret;
                };


                Promise.onPossiblyUnhandledRejection =
                function Promise$OnPossiblyUnhandledRejection(fn) {
                    CapturedTrace.possiblyUnhandledRejection = typeof fn === "function"
                                                                ? fn : void 0;
                };


                var unhandledRejectionHandled;
                Promise.onUnhandledRejectionHandled =
                function Promise$onUnhandledRejectionHandled(fn) {
                    unhandledRejectionHandled = typeof fn === "function" ? fn : void 0;
                };


                var debugging = false || !!(
                    typeof process !== "undefined" &&
                    typeof process.execPath === "string" &&
                    typeof process.env === "object" &&
                    (process.env["BLUEBIRD_DEBUG"] ||
                        process.env["NODE_ENV"] === "development")
                );




                Promise.longStackTraces = function Promise$LongStackTraces() {
                    if (async.haveItemsQueued() &&
                        debugging === false
                   ) {
                        throw new Error("cannot enable long stack traces after promises have been created");
                    }
                    debugging = CapturedTrace.isSupported();
                };


                Promise.hasLongStackTraces = function Promise$HasLongStackTraces() {
                    return debugging && CapturedTrace.isSupported();
                };


                Promise.prototype._then =
                function Promise$_then(
                    didFulfill,
                    didReject,
                    didProgress,
                    receiver,
                    internalData
                ) {
                    var haveInternalData = internalData !== void 0;
                    var ret = haveInternalData ? internalData : new Promise(INTERNAL);


                    if (!haveInternalData) {
                        if (debugging) {
                            var haveSameContext = this._peekContext() === this._traceParent;
                            ret._traceParent = haveSameContext ? this._traceParent : this;
                        }
                        ret._propagateFrom(this, 7);
                    }


                    var callbackIndex =
                        this._addCallbacks(didFulfill, didReject, didProgress, ret, receiver);


                    if (this.isResolved()) {
                        async.invoke(this._queueSettleAt, this, callbackIndex);
                    }


                    return ret;
                };


                Promise.prototype._length = function Promise$_length() {
                    return this._bitField & 262143;
                };


                Promise.prototype._isFollowingOrFulfilledOrRejected =
                function Promise$_isFollowingOrFulfilledOrRejected() {
                    return (this._bitField & 939524096) > 0;
                };


                Promise.prototype._isFollowing = function Promise$_isFollowing() {
                    return (this._bitField & 536870912) === 536870912;
                };


                Promise.prototype._setLength = function Promise$_setLength(len) {
                    this._bitField = (this._bitField & -262144) |
                        (len & 262143);
                };


                Promise.prototype._setFulfilled = function Promise$_setFulfilled() {
                    this._bitField = this._bitField | 268435456;
                };


                Promise.prototype._setRejected = function Promise$_setRejected() {
                    this._bitField = this._bitField | 134217728;
                };


                Promise.prototype._setFollowing = function Promise$_setFollowing() {
                    this._bitField = this._bitField | 536870912;
                };


                Promise.prototype._setIsFinal = function Promise$_setIsFinal() {
                    this._bitField = this._bitField | 33554432;
                };


                Promise.prototype._isFinal = function Promise$_isFinal() {
                    return (this._bitField & 33554432) > 0;
                };


                Promise.prototype._cancellable = function Promise$_cancellable() {
                    return (this._bitField & 67108864) > 0;
                };


                Promise.prototype._setCancellable = function Promise$_setCancellable() {
                    this._bitField = this._bitField | 67108864;
                };


                Promise.prototype._unsetCancellable = function Promise$_unsetCancellable() {
                    this._bitField = this._bitField & (~67108864);
                };


                Promise.prototype._setRejectionIsUnhandled =
                function Promise$_setRejectionIsUnhandled() {
                    this._bitField = this._bitField | 2097152;
                };


                Promise.prototype._unsetRejectionIsUnhandled =
                function Promise$_unsetRejectionIsUnhandled() {
                    this._bitField = this._bitField & (~2097152);
                    if (this._isUnhandledRejectionNotified()) {
                        this._unsetUnhandledRejectionIsNotified();
                        this._notifyUnhandledRejectionIsHandled();
                    }
                };


                Promise.prototype._isRejectionUnhandled =
                function Promise$_isRejectionUnhandled() {
                    return (this._bitField & 2097152) > 0;
                };


                Promise.prototype._setUnhandledRejectionIsNotified =
                function Promise$_setUnhandledRejectionIsNotified() {
                    this._bitField = this._bitField | 524288;
                };


                Promise.prototype._unsetUnhandledRejectionIsNotified =
                function Promise$_unsetUnhandledRejectionIsNotified() {
                    this._bitField = this._bitField & (~524288);
                };


                Promise.prototype._isUnhandledRejectionNotified =
                function Promise$_isUnhandledRejectionNotified() {
                    return (this._bitField & 524288) > 0;
                };


                Promise.prototype._setCarriedStackTrace =
                function Promise$_setCarriedStackTrace(capturedTrace) {
                    this._bitField = this._bitField | 1048576;
                    this._fulfillmentHandler0 = capturedTrace;
                };


                Promise.prototype._unsetCarriedStackTrace =
                function Promise$_unsetCarriedStackTrace() {
                    this._bitField = this._bitField & (~1048576);
                    this._fulfillmentHandler0 = void 0;
                };


                Promise.prototype._isCarryingStackTrace =
                function Promise$_isCarryingStackTrace() {
                    return (this._bitField & 1048576) > 0;
                };


                Promise.prototype._getCarriedStackTrace =
                function Promise$_getCarriedStackTrace() {
                    return this._isCarryingStackTrace()
                        ? this._fulfillmentHandler0
                        : void 0;
                };


                Promise.prototype._receiverAt = function Promise$_receiverAt(index) {
                    var ret = index === 0
                        ? this._receiver0
                        : this[(index << 2) + index - 5 + 4];
                    if (this._isBound() && ret === void 0) {
                        return this._boundTo;
                    }
                    return ret;
                };


                Promise.prototype._promiseAt = function Promise$_promiseAt(index) {
                    return index === 0
                        ? this._promise0
                        : this[(index << 2) + index - 5 + 3];
                };


                Promise.prototype._fulfillmentHandlerAt =
                function Promise$_fulfillmentHandlerAt(index) {
                    return index === 0
                        ? this._fulfillmentHandler0
                        : this[(index << 2) + index - 5 + 0];
                };


                Promise.prototype._rejectionHandlerAt =
                function Promise$_rejectionHandlerAt(index) {
                    return index === 0
                        ? this._rejectionHandler0
                        : this[(index << 2) + index - 5 + 1];
                };


                Promise.prototype._addCallbacks = function Promise$_addCallbacks(
                    fulfill,
                    reject,
                    progress,
                    promise,
                    receiver
                ) {
                    var index = this._length();


                    if (index >= 262143 - 5) {
                        index = 0;
                        this._setLength(0);
                    }


                    if (index === 0) {
                        this._promise0 = promise;
                        if (receiver !== void 0) this._receiver0 = receiver;
                        if (typeof fulfill === "function" && !this._isCarryingStackTrace())
                            this._fulfillmentHandler0 = fulfill;
                        if (typeof reject === "function") this._rejectionHandler0 = reject;
                        if (typeof progress === "function") this._progressHandler0 = progress;
                    } else {
                        var base = (index << 2) + index - 5;
                        this[base + 3] = promise;
                        this[base + 4] = receiver;
                        this[base + 0] = typeof fulfill === "function"
                                                            ? fulfill : void 0;
                        this[base + 1] = typeof reject === "function"
                                                            ? reject : void 0;
                        this[base + 2] = typeof progress === "function"
                                                            ? progress : void 0;
                    }
                    this._setLength(index + 1);
                    return index;
                };


                Promise.prototype._setProxyHandlers =
                function Promise$_setProxyHandlers(receiver, promiseSlotValue) {
                    var index = this._length();


                    if (index >= 262143 - 5) {
                        index = 0;
                        this._setLength(0);
                    }
                    if (index === 0) {
                        this._promise0 = promiseSlotValue;
                        this._receiver0 = receiver;
                    } else {
                        var base = (index << 2) + index - 5;
                        this[base + 3] = promiseSlotValue;
                        this[base + 4] = receiver;
                        this[base + 0] =
                        this[base + 1] =
                        this[base + 2] = void 0;
                    }
                    this._setLength(index + 1);
                };


                Promise.prototype._proxyPromiseArray =
                function Promise$_proxyPromiseArray(promiseArray, index) {
                    this._setProxyHandlers(promiseArray, index);
                };


                Promise.prototype._proxyPromise = function Promise$_proxyPromise(promise) {
                    promise._setProxied();
                    this._setProxyHandlers(promise, -1);
                };


                Promise.prototype._setBoundTo = function Promise$_setBoundTo(obj) {
                    if (obj !== void 0) {
                        this._bitField = this._bitField | 8388608;
                        this._boundTo = obj;
                    } else {
                        this._bitField = this._bitField & (~8388608);
                    }
                };


                Promise.prototype._isBound = function Promise$_isBound() {
                    return (this._bitField & 8388608) === 8388608;
                };


                Promise.prototype._resolveFromResolver =
                function Promise$_resolveFromResolver(resolver) {
                    var promise = this;
                    this._setTrace(void 0);
                    this._pushContext();


                    function Promise$_resolver(val) {
                        if (promise._tryFollow(val)) {
                            return;
                        }
                        promise._fulfill(val);
                    }
                    function Promise$_rejecter(val) {
                        var trace = canAttach(val) ? val : new Error(val + "");
                        promise._attachExtraTrace(trace);
                        markAsOriginatingFromRejection(val);
                        promise._reject(val, trace === val ? void 0 : trace);
                    }
                    var r = tryCatch2(resolver, void 0, Promise$_resolver, Promise$_rejecter);
                    this._popContext();


                    if (r !== void 0 && r === errorObj) {
                        var e = r.e;
                        var trace = canAttach(e) ? e : new Error(e + "");
                        promise._reject(e, trace);
                    }
                };


                Promise.prototype._spreadSlowCase =
                function Promise$_spreadSlowCase(targetFn, promise, values, boundTo) {
                    var promiseForAll = new PromiseArray(values).promise();
                    var promise2 = promiseForAll._then(function () {
                        return targetFn.apply(boundTo, arguments);
                    }, void 0, void 0, APPLY, void 0);
                    promise._follow(promise2);
                };


                Promise.prototype._callSpread =
                function Promise$_callSpread(handler, promise, value) {
                    var boundTo = this._boundTo;
                    if (isArray(value)) {
                        for (var i = 0, len = value.length; i < len; ++i) {
                            if (cast(value[i], void 0) instanceof Promise) {
                                this._spreadSlowCase(handler, promise, value, boundTo);
                                return;
                            }
                        }
                    }
                    promise._pushContext();
                    return tryCatchApply(handler, value, boundTo);
                };


                Promise.prototype._callHandler =
                function Promise$_callHandler(
                    handler, receiver, promise, value) {
                    var x;
                    if (receiver === APPLY && !this.isRejected()) {
                        x = this._callSpread(handler, promise, value);
                    } else {
                        promise._pushContext();
                        x = tryCatch1(handler, receiver, value);
                    }
                    promise._popContext();
                    return x;
                };


                Promise.prototype._settlePromiseFromHandler =
                function Promise$_settlePromiseFromHandler(
                    handler, receiver, value, promise
                ) {
                    if (!(promise instanceof Promise)) {
                        handler.call(receiver, value, promise);
                        return;
                    }
                    var x = this._callHandler(handler, receiver, promise, value);
                    if (promise._isFollowing()) return;


                    if (x === errorObj || x === promise || x === NEXT_FILTER) {
                        var err = x === promise
                                    ? makeSelfResolutionError()
                                    : x.e;
                        var trace = canAttach(err) ? err : new Error(err + "");
                        if (x !== NEXT_FILTER) promise._attachExtraTrace(trace);
                        promise._rejectUnchecked(err, trace);
                    } else {
                        var castValue = cast(x, promise);
                        if (castValue instanceof Promise) {
                            if (castValue.isRejected() &&
                                !castValue._isCarryingStackTrace() &&
                                !canAttach(castValue._settledValue)) {
                                var trace = new Error(castValue._settledValue + "");
                                promise._attachExtraTrace(trace);
                                castValue._setCarriedStackTrace(trace);
                            }
                            promise._follow(castValue);
                            promise._propagateFrom(castValue, 1);
                        } else {
                            promise._fulfillUnchecked(x);
                        }
                    }
                };


                Promise.prototype._follow =
                function Promise$_follow(promise) {
                    this._setFollowing();


                    if (promise.isPending()) {
                        this._propagateFrom(promise, 1);
                        promise._proxyPromise(this);
                    } else if (promise.isFulfilled()) {
                        this._fulfillUnchecked(promise._settledValue);
                    } else {
                        this._rejectUnchecked(promise._settledValue,
                            promise._getCarriedStackTrace());
                    }


                    if (promise._isRejectionUnhandled()) promise._unsetRejectionIsUnhandled();


                    if (debugging &&
                        promise._traceParent == null) {
                        promise._traceParent = this;
                    }
                };


                Promise.prototype._tryFollow =
                function Promise$_tryFollow(value) {
                    if (this._isFollowingOrFulfilledOrRejected() ||
                        value === this) {
                        return false;
                    }
                    var maybePromise = cast(value, void 0);
                    if (!(maybePromise instanceof Promise)) {
                        return false;
                    }
                    this._follow(maybePromise);
                    return true;
                };


                Promise.prototype._resetTrace = function Promise$_resetTrace() {
                    if (debugging) {
                        this._trace = new CapturedTrace(this._peekContext() === void 0);
                    }
                };


                Promise.prototype._setTrace = function Promise$_setTrace(parent) {
                    if (debugging) {
                        var context = this._peekContext();
                        this._traceParent = context;
                        var isTopLevel = context === void 0;
                        if (parent !== void 0 &&
                            parent._traceParent === context) {
                            this._trace = parent._trace;
                        } else {
                            this._trace = new CapturedTrace(isTopLevel);
                        }
                    }
                    return this;
                };


                Promise.prototype._attachExtraTrace =
                function Promise$_attachExtraTrace(error) {
                    if (debugging) {
                        var promise = this;
                        var stack = error.stack;
                        stack = typeof stack === "string"
                            ? stack.split("\n") : [];
                        var headerLineCount = 1;
                        var combinedTraces = 1;
                        while (promise != null &&
                            promise._trace != null) {
                            stack = CapturedTrace.combine(
                                stack,
                                promise._trace.stack.split("\n")
                            );
                            promise = promise._traceParent;
                            combinedTraces++;
                        }


                        var stackTraceLimit = Error.stackTraceLimit || 10;
                        var max = (stackTraceLimit + headerLineCount) * combinedTraces;
                        var len = stack.length;
                        if (len > max) {
                            stack.length = max;
                        }
                        if (stack.length <= headerLineCount) {
                            error.stack = "(No stack trace)";
                        } else {
                            error.stack = stack.join("\n");
                        }
                    }
                };


                Promise.prototype._cleanValues = function Promise$_cleanValues() {
                    if (this._cancellable()) {
                        this._cancellationParent = void 0;
                    }
                };


                Promise.prototype._propagateFrom =
                function Promise$_propagateFrom(parent, flags) {
                    if ((flags & 1) > 0 && parent._cancellable()) {
                        this._setCancellable();
                        this._cancellationParent = parent;
                    }
                    if ((flags & 4) > 0) {
                        this._setBoundTo(parent._boundTo);
                    }
                    if ((flags & 2) > 0) {
                        this._setTrace(parent);
                    }
                };


                Promise.prototype._fulfill = function Promise$_fulfill(value) {
                    if (this._isFollowingOrFulfilledOrRejected()) return;
                    this._fulfillUnchecked(value);
                };


                Promise.prototype._reject =
                function Promise$_reject(reason, carriedStackTrace) {
                    if (this._isFollowingOrFulfilledOrRejected()) return;
                    this._rejectUnchecked(reason, carriedStackTrace);
                };


                Promise.prototype._settlePromiseAt = function Promise$_settlePromiseAt(index) {
                    var handler = this.isFulfilled()
                        ? this._fulfillmentHandlerAt(index)
                        : this._rejectionHandlerAt(index);


                    var value = this._settledValue;
                    var receiver = this._receiverAt(index);
                    var promise = this._promiseAt(index);


                    if (typeof handler === "function") {
                        this._settlePromiseFromHandler(handler, receiver, value, promise);
                    } else {
                        var done = false;
                        var isFulfilled = this.isFulfilled();
                        if (receiver !== void 0) {
                            if (receiver instanceof Promise &&
                                receiver._isProxied()) {
                                receiver._unsetProxied();


                                if (isFulfilled) receiver._fulfillUnchecked(value);
                                else receiver._rejectUnchecked(value,
                                    this._getCarriedStackTrace());
                                done = true;
                            } else if (receiver instanceof PromiseArray) {
                                if (isFulfilled) receiver._promiseFulfilled(value, promise);
                                else receiver._promiseRejected(value, promise);
                                done = true;
                            }
                        }


                        if (!done) {
                            if (isFulfilled) promise._fulfill(value);
                            else promise._reject(value, this._getCarriedStackTrace());
                        }
                    }


                    if (index >= 256) {
                        this._queueGC();
                    }
                };


                Promise.prototype._isProxied = function Promise$_isProxied() {
                    return (this._bitField & 4194304) === 4194304;
                };


                Promise.prototype._setProxied = function Promise$_setProxied() {
                    this._bitField = this._bitField | 4194304;
                };


                Promise.prototype._unsetProxied = function Promise$_unsetProxied() {
                    this._bitField = this._bitField & (~4194304);
                };


                Promise.prototype._isGcQueued = function Promise$_isGcQueued() {
                    return (this._bitField & -1073741824) === -1073741824;
                };


                Promise.prototype._setGcQueued = function Promise$_setGcQueued() {
                    this._bitField = this._bitField | -1073741824;
                };


                Promise.prototype._unsetGcQueued = function Promise$_unsetGcQueued() {
                    this._bitField = this._bitField & (~-1073741824);
                };


                Promise.prototype._queueGC = function Promise$_queueGC() {
                    if (this._isGcQueued()) return;
                    this._setGcQueued();
                    async.invokeLater(this._gc, this, void 0);
                };


                Promise.prototype._gc = function Promise$gc() {
                    var len = this._length() * 5;
                    for (var i = 0; i < len; i++) {
                        delete this[i];
                    }
                    this._setLength(0);
                    this._unsetGcQueued();
                };


                Promise.prototype._queueSettleAt = function Promise$_queueSettleAt(index) {
                    if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
                    async.invoke(this._settlePromiseAt, this, index);
                };


                Promise.prototype._fulfillUnchecked =
                function Promise$_fulfillUnchecked(value) {
                    if (!this.isPending()) return;
                    if (value === this) {
                        var err = makeSelfResolutionError();
                        this._attachExtraTrace(err);
                        return this._rejectUnchecked(err, void 0);
                    }
                    this._cleanValues();
                    this._setFulfilled();
                    this._settledValue = value;
                    var len = this._length();


                    if (len > 0) {
                        async.invoke(this._settlePromises, this, len);
                    }
                };


                Promise.prototype._rejectUncheckedCheckError =
                function Promise$_rejectUncheckedCheckError(reason) {
                    var trace = canAttach(reason) ? reason : new Error(reason + "");
                    this._rejectUnchecked(reason, trace === reason ? void 0 : trace);
                };


                Promise.prototype._rejectUnchecked =
                function Promise$_rejectUnchecked(reason, trace) {
                    if (!this.isPending()) return;
                    if (reason === this) {
                        var err = makeSelfResolutionError();
                        this._attachExtraTrace(err);
                        return this._rejectUnchecked(err);
                    }
                    this._cleanValues();
                    this._setRejected();
                    this._settledValue = reason;


                    if (this._isFinal()) {
                        async.invokeLater(thrower, void 0, trace === void 0 ? reason : trace);
                        return;
                    }
                    var len = this._length();


                    if (trace !== void 0) this._setCarriedStackTrace(trace);


                    if (len > 0) {
                        async.invoke(this._rejectPromises, this, null);
                    } else {
                        this._ensurePossibleRejectionHandled();
                    }
                };


                Promise.prototype._rejectPromises = function Promise$_rejectPromises() {
                    this._settlePromises();
                    this._unsetCarriedStackTrace();
                };


                Promise.prototype._settlePromises = function Promise$_settlePromises() {
                    var len = this._length();
                    for (var i = 0; i < len; i++) {
                        this._settlePromiseAt(i);
                    }
                };


                Promise.prototype._ensurePossibleRejectionHandled =
                function Promise$_ensurePossibleRejectionHandled() {
                    this._setRejectionIsUnhandled();
                    if (CapturedTrace.possiblyUnhandledRejection !== void 0) {
                        async.invokeLater(this._notifyUnhandledRejection, this, void 0);
                    }
                };


                Promise.prototype._notifyUnhandledRejectionIsHandled =
                function Promise$_notifyUnhandledRejectionIsHandled() {
                    if (typeof unhandledRejectionHandled === "function") {
                        async.invokeLater(unhandledRejectionHandled, void 0, this);
                    }
                };


                Promise.prototype._notifyUnhandledRejection =
                function Promise$_notifyUnhandledRejection() {
                    if (this._isRejectionUnhandled()) {
                        var reason = this._settledValue;
                        var trace = this._getCarriedStackTrace();


                        this._setUnhandledRejectionIsNotified();


                        if (trace !== void 0) {
                            this._unsetCarriedStackTrace();
                            reason = trace;
                        }
                        if (typeof CapturedTrace.possiblyUnhandledRejection === "function") {
                            CapturedTrace.possiblyUnhandledRejection(reason, this);
                        }
                    }
                };


                var contextStack = [];
                Promise.prototype._peekContext = function Promise$_peekContext() {
                    var lastIndex = contextStack.length - 1;
                    if (lastIndex >= 0) {
                        return contextStack[lastIndex];
                    }
                    return void 0;


                };


                Promise.prototype._pushContext = function Promise$_pushContext() {
                    if (!debugging) return;
                    contextStack.push(this);
                };


                Promise.prototype._popContext = function Promise$_popContext() {
                    if (!debugging) return;
                    contextStack.pop();
                };


                Promise.noConflict = function Promise$NoConflict() {
                    return noConflict(Promise);
                };


                Promise.setScheduler = function (fn) {
                    if (typeof fn !== "function") throw new TypeError("fn must be a function");
                    async._schedule = fn;
                };


                if (!CapturedTrace.isSupported()) {
                    Promise.longStackTraces = function () { };
                    debugging = false;
                }


                Promise._makeSelfResolutionError = makeSelfResolutionError;
                require("./finally.js")(Promise, NEXT_FILTER, cast);
                require("./direct_resolve.js")(Promise);
                require("./synchronous_inspection.js")(Promise);
                require("./join.js")(Promise, PromiseArray, cast, INTERNAL);
                Promise.RangeError = RangeError;
                Promise.CancellationError = CancellationError;
                Promise.TimeoutError = TimeoutError;
                Promise.TypeError = TypeError;
                Promise.OperationalError = OperationalError;
                Promise.RejectionError = OperationalError;
                Promise.AggregateError = errors.AggregateError;


                util.toFastProperties(Promise);
                util.toFastProperties(Promise.prototype);
                Promise.Promise = Promise;
                require('./timers.js')(Promise, INTERNAL, cast);
                require('./race.js')(Promise, INTERNAL, cast);
                require('./call_get.js')(Promise);
                require('./generators.js')(Promise, apiRejection, INTERNAL, cast);
                require('./map.js')(Promise, PromiseArray, apiRejection, cast, INTERNAL);
                require('./nodeify.js')(Promise);
                require('./promisify.js')(Promise, INTERNAL);
                require('./props.js')(Promise, PromiseArray, cast);
                require('./reduce.js')(Promise, PromiseArray, apiRejection, cast, INTERNAL);
                require('./settle.js')(Promise, PromiseArray);
                require('./some.js')(Promise, PromiseArray, apiRejection);
                require('./progress.js')(Promise, PromiseArray);
                require('./cancel.js')(Promise, INTERNAL);
                require('./filter.js')(Promise, INTERNAL);
                require('./any.js')(Promise, PromiseArray);
                require('./each.js')(Promise, INTERNAL);
                require('./using.js')(Promise, apiRejection, cast);


                Promise.prototype = Promise.prototype;
                return Promise;


            };


        }, { "./any.js": 1, "./async.js": 2, "./call_get.js": 4, "./cancel.js": 5, "./captured_trace.js": 6, "./catch_filter.js": 7, "./direct_resolve.js": 8, "./each.js": 9, "./errors.js": 10, "./errors_api_rejection": 11, "./filter.js": 13, "./finally.js": 14, "./generators.js": 15, "./join.js": 16, "./map.js": 17, "./nodeify.js": 18, "./progress.js": 19, "./promise_array.js": 21, "./promise_resolver.js": 22, "./promisify.js": 23, "./props.js": 24, "./race.js": 26, "./reduce.js": 27, "./settle.js": 29, "./some.js": 30, "./synchronous_inspection.js": 31, "./thenables.js": 32, "./timers.js": 33, "./using.js": 34, "./util.js": 35 }], 21: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL, cast) {
                var canAttach = require("./errors.js").canAttach;
                var util = require("./util.js");
                var isArray = util.isArray;


                function toResolutionValue(val) {
                    switch (val) {
                        case -1: return void 0;
                        case -2: return [];
                        case -3: return {};
                    }
                }


                function PromiseArray(values) {
                    var promise = this._promise = new Promise(INTERNAL);
                    var parent = void 0;
                    if (values instanceof Promise) {
                        parent = values;
                        promise._propagateFrom(parent, 1 | 4);
                    }
                    promise._setTrace(parent);
                    this._values = values;
                    this._length = 0;
                    this._totalResolved = 0;
                    this._init(void 0, -2);
                }
                PromiseArray.prototype.length = function PromiseArray$length() {
                    return this._length;
                };


                PromiseArray.prototype.promise = function PromiseArray$promise() {
                    return this._promise;
                };


                PromiseArray.prototype._init =
                function PromiseArray$_init(_, resolveValueIfEmpty) {
                    var values = cast(this._values, void 0);
                    if (values instanceof Promise) {
                        this._values = values;
                        values._setBoundTo(this._promise._boundTo);
                        if (values.isFulfilled()) {
                            values = values._settledValue;
                            if (!isArray(values)) {
                                var err = new Promise.TypeError("expecting an array, a promise or a thenable");
                                this.__hardReject__(err);
                                return;
                            }
                        } else if (values.isPending()) {
                            values._then(
                                PromiseArray$_init,
                                this._reject,
                                void 0,
                                this,
                                resolveValueIfEmpty
                           );
                            return;
                        } else {
                            values._unsetRejectionIsUnhandled();
                            this._reject(values._settledValue);
                            return;
                        }
                    } else if (!isArray(values)) {
                        var err = new Promise.TypeError("expecting an array, a promise or a thenable");
                        this.__hardReject__(err);
                        return;
                    }


                    if (values.length === 0) {
                        if (resolveValueIfEmpty === -5) {
                            this._resolveEmptyArray();
                        }
                        else {
                            this._resolve(toResolutionValue(resolveValueIfEmpty));
                        }
                        return;
                    }
                    var len = this.getActualLength(values.length);
                    var newLen = len;
                    var newValues = this.shouldCopyValues() ? new Array(len) : this._values;
                    var isDirectScanNeeded = false;
                    for (var i = 0; i < len; ++i) {
                        var maybePromise = cast(values[i], void 0);
                        if (maybePromise instanceof Promise) {
                            if (maybePromise.isPending()) {
                                maybePromise._proxyPromiseArray(this, i);
                            } else {
                                maybePromise._unsetRejectionIsUnhandled();
                                isDirectScanNeeded = true;
                            }
                        } else {
                            isDirectScanNeeded = true;
                        }
                        newValues[i] = maybePromise;
                    }
                    this._values = newValues;
                    this._length = newLen;
                    if (isDirectScanNeeded) {
                        this._scanDirectValues(len);
                    }
                };


                PromiseArray.prototype._settlePromiseAt =
                function PromiseArray$_settlePromiseAt(index) {
                    var value = this._values[index];
                    if (!(value instanceof Promise)) {
                        this._promiseFulfilled(value, index);
                    } else if (value.isFulfilled()) {
                        this._promiseFulfilled(value._settledValue, index);
                    } else if (value.isRejected()) {
                        this._promiseRejected(value._settledValue, index);
                    }
                };


                PromiseArray.prototype._scanDirectValues =
                function PromiseArray$_scanDirectValues(len) {
                    for (var i = 0; i < len; ++i) {
                        if (this._isResolved()) {
                            break;
                        }
                        this._settlePromiseAt(i);
                    }
                };


                PromiseArray.prototype._isResolved = function PromiseArray$_isResolved() {
                    return this._values === null;
                };


                PromiseArray.prototype._resolve = function PromiseArray$_resolve(value) {
                    this._values = null;
                    this._promise._fulfill(value);
                };


                PromiseArray.prototype.__hardReject__ =
                PromiseArray.prototype._reject = function PromiseArray$_reject(reason) {
                    this._values = null;
                    var trace = canAttach(reason) ? reason : new Error(reason + "");
                    this._promise._attachExtraTrace(trace);
                    this._promise._reject(reason, trace);
                };


                PromiseArray.prototype._promiseProgressed =
                function PromiseArray$_promiseProgressed(progressValue, index) {
                    if (this._isResolved()) return;
                    this._promise._progress({
                        index: index,
                        value: progressValue
                    });
                };




                PromiseArray.prototype._promiseFulfilled =
                function PromiseArray$_promiseFulfilled(value, index) {
                    if (this._isResolved()) return;
                    this._values[index] = value;
                    var totalResolved = ++this._totalResolved;
                    if (totalResolved >= this._length) {
                        this._resolve(this._values);
                    }
                };


                PromiseArray.prototype._promiseRejected =
                function PromiseArray$_promiseRejected(reason, index) {
                    if (this._isResolved()) return;
                    this._totalResolved++;
                    this._reject(reason);
                };


                PromiseArray.prototype.shouldCopyValues =
                function PromiseArray$_shouldCopyValues() {
                    return true;
                };


                PromiseArray.prototype.getActualLength =
                function PromiseArray$getActualLength(len) {
                    return len;
                };


                return PromiseArray;
            };


        }, { "./errors.js": 10, "./util.js": 35 }], 22: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var util = require("./util.js");
            var maybeWrapAsError = util.maybeWrapAsError;
            var errors = require("./errors.js");
            var TimeoutError = errors.TimeoutError;
            var OperationalError = errors.OperationalError;
            var async = require("./async.js");
            var haveGetters = util.haveGetters;
            var es5 = require("./es5.js");


            function isUntypedError(obj) {
                return obj instanceof Error &&
                    es5.getPrototypeOf(obj) === Error.prototype;
            }


            function wrapAsOperationalError(obj) {
                var ret;
                if (isUntypedError(obj)) {
                    ret = new OperationalError(obj);
                } else {
                    ret = obj;
                }
                errors.markAsOriginatingFromRejection(ret);
                return ret;
            }


            function nodebackForPromise(promise) {
                function PromiseResolver$_callback(err, value) {
                    if (promise === null) return;


                    if (err) {
                        var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
                        promise._attachExtraTrace(wrapped);
                        promise._reject(wrapped);
                    } else if (arguments.length > 2) {
                        var $_len = arguments.length; var args = new Array($_len - 1); for (var $_i = 1; $_i < $_len; ++$_i) { args[$_i - 1] = arguments[$_i]; }
                        promise._fulfill(args);
                    } else {
                        promise._fulfill(value);
                    }


                    promise = null;
                }
                return PromiseResolver$_callback;
            }




            var PromiseResolver;
            if (!haveGetters) {
                PromiseResolver = function PromiseResolver(promise) {
                    this.promise = promise;
                    this.asCallback = nodebackForPromise(promise);
                    this.callback = this.asCallback;
                };
            }
            else {
                PromiseResolver = function PromiseResolver(promise) {
                    this.promise = promise;
                };
            }
            if (haveGetters) {
                var prop = {
                    get: function () {
                        return nodebackForPromise(this.promise);
                    }
                };
                es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
                es5.defineProperty(PromiseResolver.prototype, "callback", prop);
            }


            PromiseResolver._nodebackForPromise = nodebackForPromise;


            PromiseResolver.prototype.toString = function PromiseResolver$toString() {
                return "[object PromiseResolver]";
            };


            PromiseResolver.prototype.resolve =
            PromiseResolver.prototype.fulfill = function PromiseResolver$resolve(value) {
                if (!(this instanceof PromiseResolver)) {
                    throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.");
                }


                var promise = this.promise;
                if (promise._tryFollow(value)) {
                    return;
                }
                async.invoke(promise._fulfill, promise, value);
            };


            PromiseResolver.prototype.reject = function PromiseResolver$reject(reason) {
                if (!(this instanceof PromiseResolver)) {
                    throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.");
                }


                var promise = this.promise;
                errors.markAsOriginatingFromRejection(reason);
                var trace = errors.canAttach(reason) ? reason : new Error(reason + "");
                promise._attachExtraTrace(trace);
                async.invoke(promise._reject, promise, reason);
                if (trace !== reason) {
                    async.invoke(this._setCarriedStackTrace, this, trace);
                }
            };


            PromiseResolver.prototype.progress =
            function PromiseResolver$progress(value) {
                if (!(this instanceof PromiseResolver)) {
                    throw new TypeError("Illegal invocation, resolver resolve/reject must be called within a resolver context. Consider using the promise constructor instead.");
                }
                async.invoke(this.promise._progress, this.promise, value);
            };


            PromiseResolver.prototype.cancel = function PromiseResolver$cancel() {
                async.invoke(this.promise.cancel, this.promise, void 0);
            };


            PromiseResolver.prototype.timeout = function PromiseResolver$timeout() {
                this.reject(new TimeoutError("timeout"));
            };


            PromiseResolver.prototype.isResolved = function PromiseResolver$isResolved() {
                return this.promise.isResolved();
            };


            PromiseResolver.prototype.toJSON = function PromiseResolver$toJSON() {
                return this.promise.toJSON();
            };


            PromiseResolver.prototype._setCarriedStackTrace =
            function PromiseResolver$_setCarriedStackTrace(trace) {
                if (this.promise.isRejected()) {
                    this.promise._setCarriedStackTrace(trace);
                }
            };


            module.exports = PromiseResolver;


        }, { "./async.js": 2, "./errors.js": 10, "./es5.js": 12, "./util.js": 35 }], 23: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL) {
                var THIS = {};
                var util = require("./util.js");
                var nodebackForPromise = require("./promise_resolver.js")
                    ._nodebackForPromise;
                var withAppended = util.withAppended;
                var maybeWrapAsError = util.maybeWrapAsError;
                var canEvaluate = util.canEvaluate;
                var TypeError = require("./errors").TypeError;
                var defaultSuffix = "Async";
                var defaultFilter = function (name, func) {
                    return util.isIdentifier(name) &&
                        name.charAt(0) !== "_" &&
                        !util.isClass(func);
                };
                var defaultPromisified = { __isPromisified__: true };




                function escapeIdentRegex(str) {
                    return str.replace(/([$])/, "\\$");
                }


                function isPromisified(fn) {
                    try {
                        return fn.__isPromisified__ === true;
                    }
                    catch (e) {
                        return false;
                    }
                }


                function hasPromisified(obj, key, suffix) {
                    var val = util.getDataPropertyOrDefault(obj, key + suffix,
                                                            defaultPromisified);
                    return val ? isPromisified(val) : false;
                }
                function checkValid(ret, suffix, suffixRegexp) {
                    for (var i = 0; i < ret.length; i += 2) {
                        var key = ret[i];
                        if (suffixRegexp.test(key)) {
                            var keyWithoutAsyncSuffix = key.replace(suffixRegexp, "");
                            for (var j = 0; j < ret.length; j += 2) {
                                if (ret[j] === keyWithoutAsyncSuffix) {
                                    throw new TypeError("Cannot promisify an API " +
                                        "that has normal methods with '" + suffix + "'-suffix");
                                }
                            }
                        }
                    }
                }


                function promisifiableMethods(obj, suffix, suffixRegexp, filter) {
                    var keys = util.inheritedDataKeys(obj);
                    var ret = [];
                    for (var i = 0; i < keys.length; ++i) {
                        var key = keys[i];
                        var value = obj[key];
                        if (typeof value === "function" &&
                            !isPromisified(value) &&
                            !hasPromisified(obj, key, suffix) &&
                            filter(key, value, obj)) {
                            ret.push(key, value);
                        }
                    }
                    checkValid(ret, suffix, suffixRegexp);
                    return ret;
                }


                function switchCaseArgumentOrder(likelyArgumentCount) {
                    var ret = [likelyArgumentCount];
                    var min = Math.max(0, likelyArgumentCount - 1 - 5);
                    for (var i = likelyArgumentCount - 1; i >= min; --i) {
                        if (i === likelyArgumentCount) continue;
                        ret.push(i);
                    }
                    for (var i = likelyArgumentCount + 1; i <= 5; ++i) {
                        ret.push(i);
                    }
                    return ret;
                }


                function argumentSequence(argumentCount) {
                    return util.filledRange(argumentCount, "arguments[", "]");
                }


                function parameterDeclaration(parameterCount) {
                    return util.filledRange(parameterCount, "_arg", "");
                }


                function parameterCount(fn) {
                    if (typeof fn.length === "number") {
                        return Math.max(Math.min(fn.length, 1023 + 1), 0);
                    }
                    return 0;
                }


                function generatePropertyAccess(key) {
                    if (util.isIdentifier(key)) {
                        return "." + key;
                    }
                    else return "['" + key.replace(/(['\\])/g, "\\$1") + "']";
                }


                function makeNodePromisifiedEval(callback, receiver, originalName, fn, suffix) {
                    var newParameterCount = Math.max(0, parameterCount(fn) - 1);
                    var argumentOrder = switchCaseArgumentOrder(newParameterCount);
                    var callbackName =
                        (typeof originalName === "string" && util.isIdentifier(originalName)
                            ? originalName + suffix
                            : "promisified");


                    function generateCallForArgumentCount(count) {
                        var args = argumentSequence(count).join(", ");
                        var comma = count > 0 ? ", " : "";
                        var ret;
                        if (typeof callback === "string") {
                            ret = "                                                          \n\
                this.method(args, fn);                                       \n\
                break;                                                       \n\
            ".replace(".method", generatePropertyAccess(callback));
                        } else if (receiver === THIS) {
                            ret = "                                                         \n\
                callback.call(this, args, fn);                               \n\
                break;                                                       \n\
            ";
                        } else if (receiver !== void 0) {
                            ret = "                                                         \n\
                callback.call(receiver, args, fn);                           \n\
                break;                                                       \n\
            ";
                        } else {
                            ret = "                                                         \n\
                callback(args, fn);                                          \n\
                break;                                                       \n\
            ";
                        }
                        return ret.replace("args", args).replace(", ", comma);
                    }


                    function generateArgumentSwitchCase() {
                        var ret = "";
                        for (var i = 0; i < argumentOrder.length; ++i) {
                            ret += "case " + argumentOrder[i] + ":" +
                                generateCallForArgumentCount(argumentOrder[i]);
                        }
                        var codeForCall;
                        if (typeof callback === "string") {
                            codeForCall = "                                                  \n\
                this.property.apply(this, args);                             \n\
            "
                                .replace(".property", generatePropertyAccess(callback));
                        } else if (receiver === THIS) {
                            codeForCall = "                                                  \n\
                callback.apply(this, args);                                  \n\
            ";
                        } else {
                            codeForCall = "                                                  \n\
                callback.apply(receiver, args);                              \n\
            ";
                        }


                        ret += "                                                             \n\
        default:                                                             \n\
            var args = new Array(len + 1);                                   \n\
            var i = 0;                                                       \n\
            for (var i = 0; i < len; ++i) {                                  \n\
               args[i] = arguments[i];                                       \n\
            }                                                                \n\
            args[i] = fn;                                                    \n\
            [CodeForCall]                                                    \n\
            break;                                                           \n\
        ".replace("[CodeForCall]", codeForCall);
                        return ret;
                    }


                    return new Function("Promise",
                                        "callback",
                                        "receiver",
                                        "withAppended",
                                        "maybeWrapAsError",
                                        "nodebackForPromise",
                                        "INTERNAL", "                                         \n\
        var ret = function FunctionName(Parameters) {                        \n\
            'use strict';                                                    \n\
            var len = arguments.length;                                      \n\
            var promise = new Promise(INTERNAL);                             \n\
            promise._setTrace(void 0);                                       \n\
            var fn = nodebackForPromise(promise);                            \n\
            try {                                                            \n\
                switch(len) {                                                \n\
                    [CodeForSwitchCase]                                      \n\
                }                                                            \n\
            } catch (e) {                                                    \n\
                var wrapped = maybeWrapAsError(e);                           \n\
                promise._attachExtraTrace(wrapped);                          \n\
                promise._reject(wrapped);                                    \n\
            }                                                                \n\
            return promise;                                                  \n\
        };                                                                   \n\
        ret.__isPromisified__ = true;                                        \n\
        return ret;                                                          \n\
        "
                        .replace("FunctionName", callbackName)
                        .replace("Parameters", parameterDeclaration(newParameterCount))
                        .replace("[CodeForSwitchCase]", generateArgumentSwitchCase()))(
                            Promise,
                            callback,
                            receiver,
                            withAppended,
                            maybeWrapAsError,
                            nodebackForPromise,
                            INTERNAL
                        );
                }


                function makeNodePromisifiedClosure(callback, receiver) {
                    function promisified() {
                        var _receiver = receiver;
                        if (receiver === THIS) _receiver = this;
                        if (typeof callback === "string") {
                            callback = _receiver[callback];
                        }
                        var promise = new Promise(INTERNAL);
                        promise._setTrace(void 0);
                        var fn = nodebackForPromise(promise);
                        try {
                            callback.apply(_receiver, withAppended(arguments, fn));
                        } catch (e) {
                            var wrapped = maybeWrapAsError(e);
                            promise._attachExtraTrace(wrapped);
                            promise._reject(wrapped);
                        }
                        return promise;
                    }
                    promisified.__isPromisified__ = true;
                    return promisified;
                }


                var makeNodePromisified = canEvaluate
                    ? makeNodePromisifiedEval
                    : makeNodePromisifiedClosure;


                function promisifyAll(obj, suffix, filter, promisifier) {
                    var suffixRegexp = new RegExp(escapeIdentRegex(suffix) + "$");
                    var methods =
                        promisifiableMethods(obj, suffix, suffixRegexp, filter);


                    for (var i = 0, len = methods.length; i < len; i += 2) {
                        var key = methods[i];
                        var fn = methods[i + 1];
                        var promisifiedKey = key + suffix;
                        obj[promisifiedKey] = promisifier === makeNodePromisified
                                ? makeNodePromisified(key, THIS, key, fn, suffix)
                                : promisifier(fn);
                    }
                    util.toFastProperties(obj);
                    return obj;
                }


                function promisify(callback, receiver) {
                    return makeNodePromisified(callback, receiver, void 0, callback);
                }


                Promise.promisify = function Promise$Promisify(fn, receiver) {
                    if (typeof fn !== "function") {
                        throw new TypeError("fn must be a function");
                    }
                    if (isPromisified(fn)) {
                        return fn;
                    }
                    return promisify(fn, arguments.length < 2 ? THIS : receiver);
                };


                Promise.promisifyAll = function Promise$PromisifyAll(target, options) {
                    if (typeof target !== "function" && typeof target !== "object") {
                        throw new TypeError("the target of promisifyAll must be an object or a function");
                    }
                    options = Object(options);
                    var suffix = options.suffix;
                    if (typeof suffix !== "string") suffix = defaultSuffix;
                    var filter = options.filter;
                    if (typeof filter !== "function") filter = defaultFilter;
                    var promisifier = options.promisifier;
                    if (typeof promisifier !== "function") promisifier = makeNodePromisified;


                    if (!util.isIdentifier(suffix)) {
                        throw new RangeError("suffix must be a valid identifier");
                    }


                    var keys = util.inheritedDataKeys(target, { includeHidden: true });
                    for (var i = 0; i < keys.length; ++i) {
                        var value = target[keys[i]];
                        if (keys[i] !== "constructor" &&
                            util.isClass(value)) {
                            promisifyAll(value.prototype, suffix, filter, promisifier);
                            promisifyAll(value, suffix, filter, promisifier);
                        }
                    }


                    return promisifyAll(target, suffix, filter, promisifier);
                };
            };




        }, { "./errors": 10, "./promise_resolver.js": 22, "./util.js": 35 }], 24: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, PromiseArray, cast) {
                var util = require("./util.js");
                var apiRejection = require("./errors_api_rejection")(Promise);
                var isObject = util.isObject;
                var es5 = require("./es5.js");


                function PropertiesPromiseArray(obj) {
                    var keys = es5.keys(obj);
                    var len = keys.length;
                    var values = new Array(len * 2);
                    for (var i = 0; i < len; ++i) {
                        var key = keys[i];
                        values[i] = obj[key];
                        values[i + len] = key;
                    }
                    this.constructor$(values);
                }
                util.inherits(PropertiesPromiseArray, PromiseArray);


                PropertiesPromiseArray.prototype._init =
                function PropertiesPromiseArray$_init() {
                    this._init$(void 0, -3);
                };


                PropertiesPromiseArray.prototype._promiseFulfilled =
                function PropertiesPromiseArray$_promiseFulfilled(value, index) {
                    if (this._isResolved()) return;
                    this._values[index] = value;
                    var totalResolved = ++this._totalResolved;
                    if (totalResolved >= this._length) {
                        var val = {};
                        var keyOffset = this.length();
                        for (var i = 0, len = this.length() ; i < len; ++i) {
                            val[this._values[i + keyOffset]] = this._values[i];
                        }
                        this._resolve(val);
                    }
                };


                PropertiesPromiseArray.prototype._promiseProgressed =
                function PropertiesPromiseArray$_promiseProgressed(value, index) {
                    if (this._isResolved()) return;


                    this._promise._progress({
                        key: this._values[index + this.length()],
                        value: value
                    });
                };


                PropertiesPromiseArray.prototype.shouldCopyValues =
                function PropertiesPromiseArray$_shouldCopyValues() {
                    return false;
                };


                PropertiesPromiseArray.prototype.getActualLength =
                function PropertiesPromiseArray$getActualLength(len) {
                    return len >> 1;
                };


                function Promise$_Props(promises) {
                    var ret;
                    var castValue = cast(promises, void 0);


                    if (!isObject(castValue)) {
                        return apiRejection("cannot await properties of a non-object");
                    } else if (castValue instanceof Promise) {
                        ret = castValue._then(Promise.props, void 0, void 0, void 0, void 0);
                    } else {
                        ret = new PropertiesPromiseArray(castValue).promise();
                    }


                    if (castValue instanceof Promise) {
                        ret._propagateFrom(castValue, 4);
                    }
                    return ret;
                }


                Promise.prototype.props = function Promise$props() {
                    return Promise$_Props(this);
                };


                Promise.props = function Promise$Props(promises) {
                    return Promise$_Props(promises);
                };
            };


        }, { "./errors_api_rejection": 11, "./es5.js": 12, "./util.js": 35 }], 25: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            function arrayCopy(src, srcIndex, dst, dstIndex, len) {
                for (var j = 0; j < len; ++j) {
                    dst[j + dstIndex] = src[j + srcIndex];
                }
            }


            function Queue(capacity) {
                this._capacity = capacity;
                this._length = 0;
                this._front = 0;
                this._makeCapacity();
            }


            Queue.prototype._willBeOverCapacity =
            function Queue$_willBeOverCapacity(size) {
                return this._capacity < size;
            };


            Queue.prototype._pushOne = function Queue$_pushOne(arg) {
                var length = this.length();
                this._checkCapacity(length + 1);
                var i = (this._front + length) & (this._capacity - 1);
                this[i] = arg;
                this._length = length + 1;
            };


            Queue.prototype.push = function Queue$push(fn, receiver, arg) {
                var length = this.length() + 3;
                if (this._willBeOverCapacity(length)) {
                    this._pushOne(fn);
                    this._pushOne(receiver);
                    this._pushOne(arg);
                    return;
                }
                var j = this._front + length - 3;
                this._checkCapacity(length);
                var wrapMask = this._capacity - 1;
                this[(j + 0) & wrapMask] = fn;
                this[(j + 1) & wrapMask] = receiver;
                this[(j + 2) & wrapMask] = arg;
                this._length = length;
            };


            Queue.prototype.shift = function Queue$shift() {
                var front = this._front,
                    ret = this[front];


                this[front] = void 0;
                this._front = (front + 1) & (this._capacity - 1);
                this._length--;
                return ret;
            };


            Queue.prototype.length = function Queue$length() {
                return this._length;
            };


            Queue.prototype._makeCapacity = function Queue$_makeCapacity() {
                var len = this._capacity;
                for (var i = 0; i < len; ++i) {
                    this[i] = void 0;
                }
            };


            Queue.prototype._checkCapacity = function Queue$_checkCapacity(size) {
                if (this._capacity < size) {
                    this._resizeTo(this._capacity << 3);
                }
            };


            Queue.prototype._resizeTo = function Queue$_resizeTo(capacity) {
                var oldFront = this._front;
                var oldCapacity = this._capacity;
                var oldQueue = new Array(oldCapacity);
                var length = this.length();


                arrayCopy(this, 0, oldQueue, 0, oldCapacity);
                this._capacity = capacity;
                this._makeCapacity();
                this._front = 0;
                if (oldFront + length <= oldCapacity) {
                    arrayCopy(oldQueue, oldFront, this, 0, length);
                } else {
                    var lengthBeforeWrapping =
                            length - ((oldFront + length) & (oldCapacity - 1));


                    arrayCopy(oldQueue, oldFront, this, 0, lengthBeforeWrapping);
                    arrayCopy(oldQueue, 0, this, lengthBeforeWrapping,
                                length - lengthBeforeWrapping);
                }
            };


            module.exports = Queue;


        }, {}], 26: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL, cast) {
                var apiRejection = require("./errors_api_rejection.js")(Promise);
                var isArray = require("./util.js").isArray;


                var raceLater = function Promise$_raceLater(promise) {
                    return promise.then(function (array) {
                        return Promise$_Race(array, promise);
                    });
                };


                var hasOwn = {}.hasOwnProperty;
                function Promise$_Race(promises, parent) {
                    var maybePromise = cast(promises, void 0);


                    if (maybePromise instanceof Promise) {
                        return raceLater(maybePromise);
                    } else if (!isArray(promises)) {
                        return apiRejection("expecting an array, a promise or a thenable");
                    }


                    var ret = new Promise(INTERNAL);
                    if (parent !== void 0) {
                        ret._propagateFrom(parent, 7);
                    } else {
                        ret._setTrace(void 0);
                    }
                    var fulfill = ret._fulfill;
                    var reject = ret._reject;
                    for (var i = 0, len = promises.length; i < len; ++i) {
                        var val = promises[i];


                        if (val === void 0 && !(hasOwn.call(promises, i))) {
                            continue;
                        }


                        Promise.cast(val)._then(fulfill, reject, void 0, ret, null);
                    }
                    return ret;
                }


                Promise.race = function Promise$Race(promises) {
                    return Promise$_Race(promises, void 0);
                };


                Promise.prototype.race = function Promise$race() {
                    return Promise$_Race(this, void 0);
                };


            };


        }, { "./errors_api_rejection.js": 11, "./util.js": 35 }], 27: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, PromiseArray, apiRejection, cast, INTERNAL) {
                var util = require("./util.js");
                var tryCatch4 = util.tryCatch4;
                var tryCatch3 = util.tryCatch3;
                var errorObj = util.errorObj;
                var PENDING = {};
                function ReductionPromiseArray(promises, fn, accum, _each) {
                    this.constructor$(promises);
                    var currentIndex = -2;
                    this._preservedValues = _each === INTERNAL ? [] : null;
                    var maybePromise = cast(accum, void 0);
                    var rejected = false;
                    var isPromise = maybePromise instanceof Promise;
                    if (isPromise) {
                        if (maybePromise.isPending()) {
                            currentIndex = -1;
                            maybePromise._proxyPromiseArray(this, -1);
                        } else if (maybePromise.isFulfilled()) {
                            accum = maybePromise.value();
                            currentIndex = 0;
                        } else {
                            maybePromise._unsetRejectionIsUnhandled();
                            this._reject(maybePromise.reason());
                            rejected = true;
                        }
                    }
                    if (!isPromise && accum !== void 0) currentIndex = 0;
                    this._callback = fn;
                    this._currentIndex = currentIndex;
                    this._accum = accum;
                    if (!rejected) this._init$(void 0, -5);
                }
                util.inherits(ReductionPromiseArray, PromiseArray);


                ReductionPromiseArray.prototype._init =
                function ReductionPromiseArray$_init() { };


                ReductionPromiseArray.prototype._resolveEmptyArray =
                function ReductionPromiseArray$_resolveEmptyArray() {
                    if (this._currentIndex !== -1) {
                        this._resolve(this._preservedValues !== null
                                        ? [] : this._accum);
                    }
                };


                ReductionPromiseArray.prototype._promiseFulfilled =
                function ReductionPromiseArray$_promiseFulfilled(value, index) {
                    var accum;
                    var values = this._values;
                    if (values === null) return;
                    var length = this.length();
                    var currentIndex = this._currentIndex;
                    if (currentIndex > index) return;
                    var preservedValues = this._preservedValues;
                    var isEach = preservedValues !== null;
                    if (index === 0 && currentIndex === -2) {
                        accum = value;
                        currentIndex = 1;
                        if (length < 2) return this._resolve(void 0);
                        value = values[1];
                    } else if (index > currentIndex) {
                        return;
                    } else if (index === -1 || values[index] === PENDING) {
                        accum = value;
                        currentIndex++;
                        if (currentIndex >= length)
                            return this._resolve(isEach ? preservedValues : accum);
                        value = values[currentIndex];
                    } else {
                        accum = this._accum;
                    }


                    var callback = this._callback;
                    var receiver = this._promise._boundTo;
                    var ret;


                    for (var i = currentIndex; i < length; ++i) {
                        if (i > currentIndex) value = values[i];


                        if (value instanceof Promise) {
                            if (value.isFulfilled()) {
                                value = value._settledValue;
                            } else if (value.isPending()) {
                                this._accum = accum;
                                this._currentIndex = i;
                                return;
                            } else {
                                value._unsetRejectionIsUnhandled();
                                return this._reject(value.reason());
                            }
                        }


                        if (isEach) {
                            preservedValues.push(value);
                            ret = tryCatch3(callback, receiver, value, i, length);
                        }
                        else {
                            ret = tryCatch4(callback, receiver, accum, value, i, length);
                        }


                        if (ret === errorObj) return this._reject(ret.e);


                        var maybePromise = cast(ret, void 0);
                        if (maybePromise instanceof Promise) {
                            if (maybePromise.isPending()) {
                                values[i] = PENDING;
                                this._accum = accum;
                                this._currentIndex = i;
                                return maybePromise._proxyPromiseArray(this, i);
                            } else if (maybePromise.isFulfilled()) {
                                ret = maybePromise.value();
                            } else {
                                maybePromise._unsetRejectionIsUnhandled();
                                return this._reject(maybePromise.reason());
                            }
                        }
                        accum = ret;
                    }
                    this._resolve(isEach ? preservedValues : accum);
                };


                function reduce(promises, fn, initialValue, _each) {
                    if (typeof fn !== "function") return apiRejection("fn must be a function");
                    var array = new ReductionPromiseArray(promises, fn, initialValue, _each);
                    return array.promise();
                }


                Promise.prototype.reduce = function Promise$reduce(fn, initialValue) {
                    return reduce(this, fn, initialValue, null);
                };


                Promise.reduce = function Promise$Reduce(promises, fn, initialValue, _each) {
                    return reduce(promises, fn, initialValue, _each);
                };
            };


        }, { "./util.js": 35 }], 28: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var schedule;
            var _MutationObserver;
            if (typeof process === "object" && typeof process.version === "string") {
                schedule = function Promise$_Scheduler(fn) {
                    process.nextTick(fn);
                };
            }
            else if ((typeof MutationObserver !== "undefined" &&
                     (_MutationObserver = MutationObserver)) ||
                     (typeof WebKitMutationObserver !== "undefined" &&
                     (_MutationObserver = WebKitMutationObserver))) {
                schedule = (function () {
                    var div = document.createElement("div");
                    var queuedFn = void 0;
                    var observer = new _MutationObserver(
                        function Promise$_Scheduler() {
                            var fn = queuedFn;
                            queuedFn = void 0;
                            fn();
                        }
                   );
                    observer.observe(div, {
                        attributes: true
                    });
                    return function Promise$_Scheduler(fn) {
                        queuedFn = fn;
                        div.setAttribute("class", "foo");
                    };


                })();
            }
            else if (typeof setTimeout !== "undefined") {
                schedule = function Promise$_Scheduler(fn) {
                    setTimeout(fn, 0);
                };
            }
            else throw new Error("no async scheduler available");
            module.exports = schedule;


        }, {}], 29: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports =
                function (Promise, PromiseArray) {
                    var PromiseInspection = Promise.PromiseInspection;
                    var util = require("./util.js");


                    function SettledPromiseArray(values) {
                        this.constructor$(values);
                    }
                    util.inherits(SettledPromiseArray, PromiseArray);


                    SettledPromiseArray.prototype._promiseResolved =
                    function SettledPromiseArray$_promiseResolved(index, inspection) {
                        this._values[index] = inspection;
                        var totalResolved = ++this._totalResolved;
                        if (totalResolved >= this._length) {
                            this._resolve(this._values);
                        }
                    };


                    SettledPromiseArray.prototype._promiseFulfilled =
                    function SettledPromiseArray$_promiseFulfilled(value, index) {
                        if (this._isResolved()) return;
                        var ret = new PromiseInspection();
                        ret._bitField = 268435456;
                        ret._settledValue = value;
                        this._promiseResolved(index, ret);
                    };
                    SettledPromiseArray.prototype._promiseRejected =
                    function SettledPromiseArray$_promiseRejected(reason, index) {
                        if (this._isResolved()) return;
                        var ret = new PromiseInspection();
                        ret._bitField = 134217728;
                        ret._settledValue = reason;
                        this._promiseResolved(index, ret);
                    };


                    Promise.settle = function Promise$Settle(promises) {
                        return new SettledPromiseArray(promises).promise();
                    };


                    Promise.prototype.settle = function Promise$settle() {
                        return new SettledPromiseArray(this).promise();
                    };
                };


        }, { "./util.js": 35 }], 30: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports =
            function (Promise, PromiseArray, apiRejection) {
                var util = require("./util.js");
                var RangeError = require("./errors.js").RangeError;
                var AggregateError = require("./errors.js").AggregateError;
                var isArray = util.isArray;




                function SomePromiseArray(values) {
                    this.constructor$(values);
                    this._howMany = 0;
                    this._unwrap = false;
                    this._initialized = false;
                }
                util.inherits(SomePromiseArray, PromiseArray);


                SomePromiseArray.prototype._init = function SomePromiseArray$_init() {
                    if (!this._initialized) {
                        return;
                    }
                    if (this._howMany === 0) {
                        this._resolve([]);
                        return;
                    }
                    this._init$(void 0, -2);
                    var isArrayResolved = isArray(this._values);
                    if (!this._isResolved() &&
                        isArrayResolved &&
                        this._howMany > this._canPossiblyFulfill()) {
                        var message = "(Promise.some) input array contains less than " +
                                        this._howMany + " promises";
                        this._reject(new RangeError(message));
                    }
                };


                SomePromiseArray.prototype.init = function SomePromiseArray$init() {
                    this._initialized = true;
                    this._init();
                };


                SomePromiseArray.prototype.setUnwrap = function SomePromiseArray$setUnwrap() {
                    this._unwrap = true;
                };


                SomePromiseArray.prototype.howMany = function SomePromiseArray$howMany() {
                    return this._howMany;
                };


                SomePromiseArray.prototype.setHowMany =
                function SomePromiseArray$setHowMany(count) {
                    if (this._isResolved()) return;
                    this._howMany = count;
                };


                SomePromiseArray.prototype._promiseFulfilled =
                function SomePromiseArray$_promiseFulfilled(value) {
                    if (this._isResolved()) return;
                    this._addFulfilled(value);
                    if (this._fulfilled() === this.howMany()) {
                        this._values.length = this.howMany();
                        if (this.howMany() === 1 && this._unwrap) {
                            this._resolve(this._values[0]);
                        } else {
                            this._resolve(this._values);
                        }
                    }


                };
                SomePromiseArray.prototype._promiseRejected =
                function SomePromiseArray$_promiseRejected(reason) {
                    if (this._isResolved()) return;
                    this._addRejected(reason);
                    if (this.howMany() > this._canPossiblyFulfill()) {
                        var e = new AggregateError();
                        for (var i = this.length() ; i < this._values.length; ++i) {
                            e.push(this._values[i]);
                        }
                        this._reject(e);
                    }
                };


                SomePromiseArray.prototype._fulfilled = function SomePromiseArray$_fulfilled() {
                    return this._totalResolved;
                };


                SomePromiseArray.prototype._rejected = function SomePromiseArray$_rejected() {
                    return this._values.length - this.length();
                };


                SomePromiseArray.prototype._addRejected =
                function SomePromiseArray$_addRejected(reason) {
                    this._values.push(reason);
                };


                SomePromiseArray.prototype._addFulfilled =
                function SomePromiseArray$_addFulfilled(value) {
                    this._values[this._totalResolved++] = value;
                };


                SomePromiseArray.prototype._canPossiblyFulfill =
                function SomePromiseArray$_canPossiblyFulfill() {
                    return this.length() - this._rejected();
                };


                function Promise$_Some(promises, howMany) {
                    if ((howMany | 0) !== howMany || howMany < 0) {
                        return apiRejection("expecting a positive integer");
                    }
                    var ret = new SomePromiseArray(promises);
                    var promise = ret.promise();
                    if (promise.isRejected()) {
                        return promise;
                    }
                    ret.setHowMany(howMany);
                    ret.init();
                    return promise;
                }


                Promise.some = function Promise$Some(promises, howMany) {
                    return Promise$_Some(promises, howMany);
                };


                Promise.prototype.some = function Promise$some(howMany) {
                    return Promise$_Some(this, howMany);
                };


                Promise._SomePromiseArray = SomePromiseArray;
            };


        }, { "./errors.js": 10, "./util.js": 35 }], 31: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise) {
                function PromiseInspection(promise) {
                    if (promise !== void 0) {
                        this._bitField = promise._bitField;
                        this._settledValue = promise.isResolved()
                            ? promise._settledValue
                            : void 0;
                    }
                    else {
                        this._bitField = 0;
                        this._settledValue = void 0;
                    }
                }


                PromiseInspection.prototype.isFulfilled =
                Promise.prototype.isFulfilled = function Promise$isFulfilled() {
                    return (this._bitField & 268435456) > 0;
                };


                PromiseInspection.prototype.isRejected =
                Promise.prototype.isRejected = function Promise$isRejected() {
                    return (this._bitField & 134217728) > 0;
                };


                PromiseInspection.prototype.isPending =
                Promise.prototype.isPending = function Promise$isPending() {
                    return (this._bitField & 402653184) === 0;
                };


                PromiseInspection.prototype.value =
                Promise.prototype.value = function Promise$value() {
                    if (!this.isFulfilled()) {
                        throw new TypeError("cannot get fulfillment value of a non-fulfilled promise");
                    }
                    return this._settledValue;
                };


                PromiseInspection.prototype.error =
                PromiseInspection.prototype.reason =
                Promise.prototype.reason = function Promise$reason() {
                    if (!this.isRejected()) {
                        throw new TypeError("cannot get rejection reason of a non-rejected promise");
                    }
                    return this._settledValue;
                };


                PromiseInspection.prototype.isResolved =
                Promise.prototype.isResolved = function Promise$isResolved() {
                    return (this._bitField & 402653184) > 0;
                };


                Promise.PromiseInspection = PromiseInspection;
            };


        }, {}], 32: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, INTERNAL) {
                var util = require("./util.js");
                var canAttach = require("./errors.js").canAttach;
                var errorObj = util.errorObj;
                var isObject = util.isObject;


                function getThen(obj) {
                    try {
                        return obj.then;
                    }
                    catch (e) {
                        errorObj.e = e;
                        return errorObj;
                    }
                }


                function Promise$_Cast(obj, originalPromise) {
                    if (isObject(obj)) {
                        if (obj instanceof Promise) {
                            return obj;
                        }
                        else if (isAnyBluebirdPromise(obj)) {
                            var ret = new Promise(INTERNAL);
                            ret._setTrace(void 0);
                            obj._then(
                                ret._fulfillUnchecked,
                                ret._rejectUncheckedCheckError,
                                ret._progressUnchecked,
                                ret,
                                null
                            );
                            ret._setFollowing();
                            return ret;
                        }
                        var then = getThen(obj);
                        if (then === errorObj) {
                            if (originalPromise !== void 0 && canAttach(then.e)) {
                                originalPromise._attachExtraTrace(then.e);
                            }
                            return Promise.reject(then.e);
                        } else if (typeof then === "function") {
                            return Promise$_doThenable(obj, then, originalPromise);
                        }
                    }
                    return obj;
                }


                var hasProp = {}.hasOwnProperty;
                function isAnyBluebirdPromise(obj) {
                    return hasProp.call(obj, "_promise0");
                }


                function Promise$_doThenable(x, then, originalPromise) {
                    var resolver = Promise.defer();
                    var called = false;
                    try {
                        then.call(
                            x,
                            Promise$_resolveFromThenable,
                            Promise$_rejectFromThenable,
                            Promise$_progressFromThenable
                        );
                    } catch (e) {
                        if (!called) {
                            called = true;
                            var trace = canAttach(e) ? e : new Error(e + "");
                            if (originalPromise !== void 0) {
                                originalPromise._attachExtraTrace(trace);
                            }
                            resolver.promise._reject(e, trace);
                        }
                    }
                    return resolver.promise;


                    function Promise$_resolveFromThenable(y) {
                        if (called) return;
                        called = true;


                        if (x === y) {
                            var e = Promise._makeSelfResolutionError();
                            if (originalPromise !== void 0) {
                                originalPromise._attachExtraTrace(e);
                            }
                            resolver.promise._reject(e, void 0);
                            return;
                        }
                        resolver.resolve(y);
                    }


                    function Promise$_rejectFromThenable(r) {
                        if (called) return;
                        called = true;
                        var trace = canAttach(r) ? r : new Error(r + "");
                        if (originalPromise !== void 0) {
                            originalPromise._attachExtraTrace(trace);
                        }
                        resolver.promise._reject(r, trace);
                    }


                    function Promise$_progressFromThenable(v) {
                        if (called) return;
                        var promise = resolver.promise;
                        if (typeof promise._progress === "function") {
                            promise._progress(v);
                        }
                    }
                }


                return Promise$_Cast;
            };


        }, { "./errors.js": 10, "./util.js": 35 }], 33: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var _setTimeout = function (fn, ms) {
                var len = arguments.length;
                var arg0 = arguments[2];
                var arg1 = arguments[3];
                var arg2 = len >= 5 ? arguments[4] : void 0;
                setTimeout(function () {
                    fn(arg0, arg1, arg2);
                }, ms);
            };


            module.exports = function (Promise, INTERNAL, cast) {
                var util = require("./util.js");
                var errors = require("./errors.js");
                var apiRejection = require("./errors_api_rejection")(Promise);
                var TimeoutError = Promise.TimeoutError;


                var afterTimeout = function Promise$_afterTimeout(promise, message, ms) {
                    if (!promise.isPending()) return;
                    if (typeof message !== "string") {
                        message = "operation timed out after" + " " + ms + " ms"
                    }
                    var err = new TimeoutError(message);
                    errors.markAsOriginatingFromRejection(err);
                    promise._attachExtraTrace(err);
                    promise._cancel(err);
                };


                var afterDelay = function Promise$_afterDelay(value, promise) {
                    promise._fulfill(value);
                };


                var delay = Promise.delay = function Promise$Delay(value, ms) {
                    if (ms === void 0) {
                        ms = value;
                        value = void 0;
                    }
                    ms = +ms;
                    var maybePromise = cast(value, void 0);
                    var promise = new Promise(INTERNAL);


                    if (maybePromise instanceof Promise) {
                        promise._propagateFrom(maybePromise, 7);
                        promise._follow(maybePromise);
                        return promise.then(function (value) {
                            return Promise.delay(value, ms);
                        });
                    } else {
                        promise._setTrace(void 0);
                        _setTimeout(afterDelay, ms, value, promise);
                    }
                    return promise;
                };


                Promise.prototype.delay = function Promise$delay(ms) {
                    return delay(this, ms);
                };


                Promise.prototype.timeout = function Promise$timeout(ms, message) {
                    ms = +ms;


                    var ret = new Promise(INTERNAL);
                    ret._propagateFrom(this, 7);
                    ret._follow(this);
                    _setTimeout(afterTimeout, ms, ret, message, ms);
                    return ret.cancellable();
                };


            };


        }, { "./errors.js": 10, "./errors_api_rejection": 11, "./util.js": 35 }], 34: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            module.exports = function (Promise, apiRejection, cast) {
                var TypeError = require("./errors.js").TypeError;
                var inherits = require("./util.js").inherits;
                var PromiseInspection = Promise.PromiseInspection;


                function inspectionMapper(inspections) {
                    var len = inspections.length;
                    for (var i = 0; i < len; ++i) {
                        var inspection = inspections[i];
                        if (inspection.isRejected()) {
                            return Promise.reject(inspection.error());
                        }
                        inspections[i] = inspection.value();
                    }
                    return inspections;
                }


                function thrower(e) {
                    setTimeout(function () { throw e; }, 0);
                }


                function dispose(resources, inspection) {
                    var i = 0;
                    var len = resources.length;
                    var ret = Promise.defer();
                    function iterator() {
                        if (i >= len) return ret.resolve();
                        var maybePromise = cast(resources[i++], void 0);
                        if (maybePromise instanceof Promise &&
                            maybePromise._isDisposable()) {
                            try {
                                maybePromise = cast(maybePromise._getDisposer()
                                                    .tryDispose(inspection), void 0);
                            } catch (e) {
                                return thrower(e);
                            }
                            if (maybePromise instanceof Promise) {
                                return maybePromise._then(iterator, thrower,
                                                          null, null, null);
                            }
                        }
                        iterator();
                    }
                    iterator();
                    return ret.promise;
                }


                function disposerSuccess(value) {
                    var inspection = new PromiseInspection();
                    inspection._settledValue = value;
                    inspection._bitField = 268435456;
                    return dispose(this, inspection).thenReturn(value);
                }


                function disposerFail(reason) {
                    var inspection = new PromiseInspection();
                    inspection._settledValue = reason;
                    inspection._bitField = 134217728;
                    return dispose(this, inspection).thenThrow(reason);
                }


                function Disposer(data, promise) {
                    this._data = data;
                    this._promise = promise;
                }


                Disposer.prototype.data = function Disposer$data() {
                    return this._data;
                };


                Disposer.prototype.promise = function Disposer$promise() {
                    return this._promise;
                };


                Disposer.prototype.resource = function Disposer$resource() {
                    if (this.promise().isFulfilled()) {
                        return this.promise().value();
                    }
                    return null;
                };


                Disposer.prototype.tryDispose = function (inspection) {
                    var resource = this.resource();
                    var ret = resource !== null
                        ? this.doDispose(resource, inspection) : null;
                    this._promise._unsetDisposable();
                    this._data = this._promise = null;
                    return ret;
                };


                function FunctionDisposer(fn, promise) {
                    this.constructor$(fn, promise);
                }
                inherits(FunctionDisposer, Disposer);


                FunctionDisposer.prototype.doDispose = function (resource, inspection) {
                    var fn = this.data();
                    return fn.call(resource, resource, inspection);
                };


                Promise.using = function Promise$using() {
                    var len = arguments.length;
                    if (len < 2) return apiRejection(
                                    "you must pass at least 2 arguments to Promise.using");
                    var fn = arguments[len - 1];
                    if (typeof fn !== "function") return apiRejection("fn must be a function");
                    len--;
                    var resources = new Array(len);
                    for (var i = 0; i < len; ++i) {
                        var resource = arguments[i];
                        if (resource instanceof Disposer) {
                            var disposer = resource;
                            resource = resource.promise();
                            resource._setDisposable(disposer);
                        }
                        resources[i] = resource;
                    }


                    return Promise.settle(resources)
                        .then(inspectionMapper)
                        .spread(fn)
                        ._then(disposerSuccess, disposerFail, void 0, resources, void 0);
                };


                Promise.prototype._setDisposable =
                function Promise$_setDisposable(disposer) {
                    this._bitField = this._bitField | 262144;
                    this._disposer = disposer;
                };


                Promise.prototype._isDisposable = function Promise$_isDisposable() {
                    return (this._bitField & 262144) > 0;
                };


                Promise.prototype._getDisposer = function Promise$_getDisposer() {
                    return this._disposer;
                };


                Promise.prototype._unsetDisposable = function Promise$_unsetDisposable() {
                    this._bitField = this._bitField & (~262144);
                    this._disposer = void 0;
                };


                Promise.prototype.disposer = function Promise$disposer(fn) {
                    if (typeof fn === "function") {
                        return new FunctionDisposer(fn, this);
                    }
                    throw new TypeError();
                };


            };


        }, { "./errors.js": 10, "./util.js": 35 }], 35: [function (require, module, exports) {
            /**
             * Copyright (c) 2014 Petka Antonov
             * 
             * Permission is hereby granted, free of charge, to any person obtaining a copy
             * of this software and associated documentation files (the "Software"), to deal
             * in the Software without restriction, including without limitation the rights
             * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             * copies of the Software, and to permit persons to whom the Software is
             * furnished to do so, subject to the following conditions:</p>
             * 
             * The above copyright notice and this permission notice shall be included in
             * all copies or substantial portions of the Software.
             * 
             * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
             * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
             * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
             * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
             * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
             * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
             * THE SOFTWARE.
             * 
             */
            "use strict";
            var es5 = require("./es5.js");
            var haveGetters = (function () {
                try {
                    var o = {};
                    es5.defineProperty(o, "f", {
                        get: function () {
                            return 3;
                        }
                    });
                    return o.f === 3;
                }
                catch (e) {
                    return false;
                }


            })();
            var canEvaluate = typeof navigator == "undefined";
            var errorObj = { e: {} };
            function tryCatch1(fn, receiver, arg) {
                try { return fn.call(receiver, arg); }
                catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }


            function tryCatch2(fn, receiver, arg, arg2) {
                try { return fn.call(receiver, arg, arg2); }
                catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }


            function tryCatch3(fn, receiver, arg, arg2, arg3) {
                try { return fn.call(receiver, arg, arg2, arg3); }
                catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }


            function tryCatch4(fn, receiver, arg, arg2, arg3, arg4) {
                try { return fn.call(receiver, arg, arg2, arg3, arg4); }
                catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }


            function tryCatchApply(fn, args, receiver) {
                try { return fn.apply(receiver, args); }
                catch (e) {
                    errorObj.e = e;
                    return errorObj;
                }
            }


            var inherits = function (Child, Parent) {
                var hasProp = {}.hasOwnProperty;


                function T() {
                    this.constructor = Child;
                    this.constructor$ = Parent;
                    for (var propertyName in Parent.prototype) {
                        if (hasProp.call(Parent.prototype, propertyName) &&
                            propertyName.charAt(propertyName.length - 1) !== "$"
                       ) {
                            this[propertyName + "$"] = Parent.prototype[propertyName];
                        }
                    }
                }
                T.prototype = Parent.prototype;
                Child.prototype = new T();
                return Child.prototype;
            };


            function asString(val) {
                return typeof val === "string" ? val : ("" + val);
            }


            function isPrimitive(val) {
                return val == null || val === true || val === false ||
                    typeof val === "string" || typeof val === "number";


            }


            function isObject(value) {
                return !isPrimitive(value);
            }


            function maybeWrapAsError(maybeError) {
                if (!isPrimitive(maybeError)) return maybeError;


                return new Error(asString(maybeError));
            }


            function withAppended(target, appendee) {
                var len = target.length;
                var ret = new Array(len + 1);
                var i;
                for (i = 0; i < len; ++i) {
                    ret[i] = target[i];
                }
                ret[i] = appendee;
                return ret;
            }


            function getDataPropertyOrDefault(obj, key, defaultValue) {
                if (es5.isES5) {
                    var desc = Object.getOwnPropertyDescriptor(obj, key);
                    if (desc != null) {
                        return desc.get == null && desc.set == null
                                ? desc.value
                                : defaultValue;
                    }
                } else {
                    return {}.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
                }
            }


            function notEnumerableProp(obj, name, value) {
                if (isPrimitive(obj)) return obj;
                var descriptor = {
                    value: value,
                    configurable: true,
                    enumerable: false,
                    writable: true
                };
                es5.defineProperty(obj, name, descriptor);
                return obj;
            }




            var wrapsPrimitiveReceiver = (function () {
                return this !== "string";
            }).call("string");


            function thrower(r) {
                throw r;
            }


            var inheritedDataKeys = (function () {
                if (es5.isES5) {
                    return function (obj, opts) {
                        var ret = [];
                        var visitedKeys = Object.create(null);
                        var getKeys = Object(opts).includeHidden
                            ? Object.getOwnPropertyNames
                            : Object.keys;
                        while (obj != null) {
                            var keys;
                            try {
                                keys = getKeys(obj);
                            } catch (e) {
                                return ret;
                            }
                            for (var i = 0; i < keys.length; ++i) {
                                var key = keys[i];
                                if (visitedKeys[key]) continue;
                                visitedKeys[key] = true;
                                var desc = Object.getOwnPropertyDescriptor(obj, key);
                                if (desc != null && desc.get == null && desc.set == null) {
                                    ret.push(key);
                                }
                            }
                            obj = es5.getPrototypeOf(obj);
                        }
                        return ret;
                    };
                } else {
                    return function (obj) {
                        var ret = [];
                        /*jshint forin:false */
                        for (var key in obj) {
                            ret.push(key);
                        }
                        return ret;
                    };
                }


            })();


            function isClass(fn) {
                try {
                    if (typeof fn === "function") {
                        var keys = es5.keys(fn.prototype);
                        return keys.length > 0 &&
                               !(keys.length === 1 && keys[0] === "constructor");
                    }
                    return false;
                } catch (e) {
                    return false;
                }
            }


            function toFastProperties(obj) {
                /*jshint -W027*/
                function f() { }
                f.prototype = obj;
                return f;
                eval(obj);
            }


            var rident = /^[a-z$_][a-z$_0-9]*$/i;
            function isIdentifier(str) {
                return rident.test(str);
            }


            function filledRange(count, prefix, suffix) {
                var ret = new Array(count);
                for (var i = 0; i < count; ++i) {
                    ret[i] = prefix + i + suffix;
                }
                return ret;
            }


            var ret = {
                isClass: isClass,
                isIdentifier: isIdentifier,
                inheritedDataKeys: inheritedDataKeys,
                getDataPropertyOrDefault: getDataPropertyOrDefault,
                thrower: thrower,
                isArray: es5.isArray,
                haveGetters: haveGetters,
                notEnumerableProp: notEnumerableProp,
                isPrimitive: isPrimitive,
                isObject: isObject,
                canEvaluate: canEvaluate,
                errorObj: errorObj,
                tryCatch1: tryCatch1,
                tryCatch2: tryCatch2,
                tryCatch3: tryCatch3,
                tryCatch4: tryCatch4,
                tryCatchApply: tryCatchApply,
                inherits: inherits,
                withAppended: withAppended,
                asString: asString,
                maybeWrapAsError: maybeWrapAsError,
                wrapsPrimitiveReceiver: wrapsPrimitiveReceiver,
                toFastProperties: toFastProperties,
                filledRange: filledRange
            };


            module.exports = ret;


        }, { "./es5.js": 12 }]
    }, {}, [3])
    (3)
});
;
